From ae15ee5cb78dbe63bbf26246e3818a6cdee801be Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Thu, 3 Oct 2024 18:16:04 -0500 Subject: [PATCH] =?UTF-8?q?=F0=9F=94=A7=20Clarify=20MMU2/MMU3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/default/Configuration_adv.h | 181 ++++++++---------- .../3DFabXYZ/Migbot/Configuration_adv.h | 181 ++++++++---------- .../examples/3DMatik/XL/Configuration_adv.h | 181 ++++++++---------- .../ADIMLab/Gantry v1/Configuration_adv.h | 181 ++++++++---------- .../ADIMLab/Gantry v2/Configuration_adv.h | 181 ++++++++---------- .../Alfawise/U20-bltouch/Configuration_adv.h | 181 ++++++++---------- .../examples/Alfawise/U20/Configuration_adv.h | 181 ++++++++---------- .../AliExpress/CL-260/Configuration_adv.h | 181 ++++++++---------- .../AliExpress/UM2pExt/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/A2/Configuration_adv.h | 181 ++++++++---------- .../examples/Anet/A2plus/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/A6/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/A8/Configuration_adv.h | 181 ++++++++---------- .../examples/Anet/A8plus/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/A9/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/E10/Configuration_adv.h | 181 ++++++++---------- .../Anet/E16/BTT SKR 1.3/Configuration_adv.h | 181 ++++++++---------- .../Anet/E16/Stock/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/ET4+/Configuration_adv.h | 181 ++++++++---------- .../examples/Anet/ET4-Pro/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/ET4/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/ET4X/Configuration_adv.h | 181 ++++++++---------- .../examples/Anet/ET5-Pro/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/ET5/Configuration_adv.h | 181 ++++++++---------- config/examples/Anet/ET5X/Configuration_adv.h | 181 ++++++++---------- .../AnyCubic/Chiron/Configuration_adv.h | 181 ++++++++---------- .../Anycubic V1/Configuration_adv.h | 181 ++++++++---------- .../Mega Zero/Anycubic V1/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../AnyCubic/Vyper/Configuration_adv.h | 181 ++++++++---------- .../Trigorilla AVR/Configuration_adv.h | 181 ++++++++---------- .../Trigorilla Pro STM32/Configuration_adv.h | 181 ++++++++---------- .../examples/AnyCubic/i3/Configuration_adv.h | 181 ++++++++---------- config/examples/ArmEd/Configuration_adv.h | 181 ++++++++---------- .../Artillery/Genius Pro/Configuration_adv.h | 181 ++++++++---------- .../Genius/BLTouch/Configuration_adv.h | 181 ++++++++---------- .../Artillery/Genius/V1/Configuration_adv.h | 181 ++++++++---------- .../Artillery/Hornet/Configuration_adv.h | 181 ++++++++---------- .../0.9 BMG - E3D V6/Configuration_adv.h | 181 ++++++++---------- .../Sidewinder X1/V1/Configuration_adv.h | 181 ++++++++---------- .../Sidewinder X2/Configuration_adv.h | 181 ++++++++---------- .../examples/Azteeg/X5GT/Configuration_adv.h | 181 ++++++++---------- .../BIBO/TouchX/cyclops/Configuration_adv.h | 181 ++++++++---------- .../default - BLTouch/Configuration_adv.h | 181 ++++++++---------- .../BIBO/TouchX/default/Configuration_adv.h | 181 ++++++++---------- .../BIQU/B1 SE Plus/Configuration_adv.h | 181 ++++++++---------- .../examples/BIQU/B1 SE/Configuration_adv.h | 181 ++++++++---------- config/examples/BIQU/B1/Configuration_adv.h | 181 ++++++++---------- config/examples/BIQU/BX/Configuration_adv.h | 181 ++++++++---------- .../examples/BIQU/Hurakan/Configuration_adv.h | 181 ++++++++---------- .../BIQU/Thunder Standard/Configuration_adv.h | 181 ++++++++---------- .../examples/BQ/Hephestos/Configuration_adv.h | 181 ++++++++---------- .../BQ/Hephestos_2/Configuration_adv.h | 181 ++++++++---------- config/examples/BQ/WITBOX/Configuration_adv.h | 181 ++++++++---------- .../CNC/miniRambo/Configuration_adv.h | 181 ++++++++---------- config/examples/CTC/A13/Configuration_adv.h | 181 ++++++++---------- config/examples/CTC/Bizer/Configuration_adv.h | 181 ++++++++---------- .../no probe/Configuration_adv.h | 181 ++++++++---------- config/examples/Cartesio/Configuration_adv.h | 181 ++++++++---------- .../Copymaster3D/300/Configuration_adv.h | 181 ++++++++---------- .../Copymaster3D/400/Configuration_adv.h | 181 ++++++++---------- .../Copymaster3D/500/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-10 Max/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CR-10 Mini/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../CR-10 Mini/MEEB-3DP/Configuration_adv.h | 181 ++++++++---------- .../CR-10 S4/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CR-10 S5/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-10 V2/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-10 V3/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CR-10/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-10S Pro/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CrealityV1 - BLTouch/Configuration_adv.h | 181 ++++++++---------- .../CR-10S/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-20 Pro/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-20/Stock/Configuration_adv.h | 181 ++++++++---------- .../CR-30 PrintMill/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-6 SE/Configuration_adv.h | 181 ++++++++---------- .../Creality/CR-8/Configuration_adv.h | 181 ++++++++---------- .../CrealityV24S4/Configuration_adv.h | 181 ++++++++---------- .../CrealityV423/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-2/Configuration_adv.h | 181 ++++++++---------- .../Ender-3 Max Neo/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-3 Max/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-3 Neo/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Creality free-runs/Configuration_adv.h | 181 ++++++++---------- .../CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../CrealityV422/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CrealityV427/Configuration_adv.h | 181 ++++++++---------- .../Ender-3 S1 Plus/Configuration_adv.h | 181 ++++++++---------- .../Ender-3 S1 Pro/Configuration_adv.h | 181 ++++++++---------- .../Ender-3 S1/STM32F1/Configuration_adv.h | 181 ++++++++---------- .../Ender-3 S1/STM32F4/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CrealityV422/Configuration_adv.h | 181 ++++++++---------- .../CrealityUI/Configuration_adv.h | 181 ++++++++---------- .../MarlinUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityUI/Configuration_adv.h | 181 ++++++++---------- .../MarlinUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityUI/Configuration_adv.h | 181 ++++++++---------- .../MarlinUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityV422/MarlinUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityUI/Configuration_adv.h | 181 ++++++++---------- .../CrealityV427/MarlinUI/Configuration_adv.h | 181 ++++++++---------- .../BigTreeTech E3 RRF/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../BigTreeTech SKR 1.4/Configuration_adv.h | 181 ++++++++---------- .../2-into-1 Hotend/Configuration_adv.h | 181 ++++++++---------- .../Dual Z/Configuration_adv.h | 181 ++++++++---------- .../Single Extruder/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Creality free-runs/Configuration_adv.h | 181 ++++++++---------- .../Ender-3/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Ender-3/CrealityV422/Configuration_adv.h | 181 ++++++++---------- .../Ender-3/CrealityV427/Configuration_adv.h | 181 ++++++++---------- .../BLTouch/Configuration_adv.h | 181 ++++++++---------- .../base/Configuration_adv.h | 181 ++++++++---------- .../FYSETC Cheetah 2.0/Configuration_adv.h | 181 ++++++++---------- .../BLTouch/Configuration_adv.h | 181 ++++++++---------- .../FYSETC Cheetah/base/Configuration_adv.h | 181 ++++++++---------- .../Ender-3/MEEB-3DP/Configuration_adv.h | 181 ++++++++---------- .../MKS Robin E3/V1.0/Configuration_adv.h | 181 ++++++++---------- .../MKS Robin E3/V1.1/Configuration_adv.h | 181 ++++++++---------- .../Ender-3/MKS Robin E3P/Configuration_adv.h | 181 ++++++++---------- .../TH3D EZBoard Lite V2/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-4/Configuration_adv.h | 181 ++++++++---------- .../BigTreeTech SKR 3/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../CrealityV422/Configuration_adv.h | 181 ++++++++---------- .../CrealityV427/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-5 S1/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Creality free-runs/Configuration_adv.h | 181 ++++++++---------- .../Ender-5/CrealityV1/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Ender-5/CrealityV427/Configuration_adv.h | 181 ++++++++---------- .../Creality/Ender-6/Configuration_adv.h | 181 ++++++++---------- .../Dagoma/Disco Ultimate/Configuration_adv.h | 181 ++++++++---------- .../Daycom/3DP-100/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../EasyThreeD/ET4000PLUS/Configuration_adv.h | 181 ++++++++---------- .../examples/Eazao/Zero/Configuration_adv.h | 181 ++++++++---------- .../examples/Einstart-S/Configuration_adv.h | 181 ++++++++---------- .../Elegoo/Neptune 2/Configuration_adv.h | 181 ++++++++---------- .../Eryone/Thinker SE/Configuration_adv.h | 181 ++++++++---------- .../Eryone/Thinker V2/Configuration_adv.h | 181 ++++++++---------- .../FYSETC/AIO_II/Configuration_adv.h | 181 ++++++++---------- .../examples/FYSETC/F6_13/Configuration_adv.h | 181 ++++++++---------- config/examples/FYSETC/S6/Configuration_adv.h | 181 ++++++++---------- .../examples/Felix/DUAL/Configuration_adv.h | 181 ++++++++---------- .../examples/Felix/Single/Configuration_adv.h | 181 ++++++++---------- .../FlashForge/Creator 2X/Configuration_adv.h | 181 ++++++++---------- .../FlashForge/CreatorPro/Configuration_adv.h | 181 ++++++++---------- .../FlyingBear/P902/Configuration_adv.h | 181 ++++++++---------- .../FlyingBear/P905H/Configuration_adv.h | 181 ++++++++---------- .../FoamCutter/generic/Configuration_adv.h | 181 ++++++++---------- .../FoamCutter/rcKeith/Configuration_adv.h | 181 ++++++++---------- .../FolgerTech/FT-5 R2/Configuration_adv.h | 181 ++++++++---------- .../FolgerTech/i3-2020/Configuration_adv.h | 181 ++++++++---------- .../Formbot/Raptor/Configuration_adv.h | 181 ++++++++---------- .../examples/Geeetech/A10/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A10D/Configuration_adv.h | 181 ++++++++---------- .../A10M/Stock LCD/Configuration_adv.h | 181 ++++++++---------- .../A10M/YHCB2004_V4.1/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A10PRO/Configuration_adv.h | 181 ++++++++---------- .../A10T/Stock LCD/Configuration_adv.h | 181 ++++++++---------- .../A10T/YHCB2004_V4.1/Configuration_adv.h | 181 ++++++++---------- .../examples/Geeetech/A20/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A20M/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A20T/Configuration_adv.h | 181 ++++++++---------- .../examples/Geeetech/A30/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A30M/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/A30T/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/D200/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/Duplicator5/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/E180/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/GT2560/Configuration_adv.h | 181 ++++++++---------- .../I3_Pro_X-GT2560/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/M201/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/MeCreator2/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/Me_creator/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/Me_ducer/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/PI3A PRO/Configuration_adv.h | 181 ++++++++---------- .../bltouch/Configuration_adv.h | 181 ++++++++---------- .../noprobe/Configuration_adv.h | 181 ++++++++---------- .../Prusa i3 Pro C/Configuration_adv.h | 181 ++++++++---------- .../Prusa i3 Pro W/Configuration_adv.h | 181 ++++++++---------- config/examples/HMS434/Configuration_adv.h | 181 ++++++++---------- .../Hictop/3DP-17/Configuration_adv.h | 181 ++++++++---------- .../Infitary/i3-M508/Configuration_adv.h | 181 ++++++++---------- .../FunmatHT 4988/Configuration_adv.h | 181 ++++++++---------- .../examples/JGAurora/A1/Configuration_adv.h | 181 ++++++++---------- .../examples/JGAurora/A3/Configuration_adv.h | 181 ++++++++---------- .../examples/JGAurora/A5/Configuration_adv.h | 181 ++++++++---------- .../examples/JGAurora/A5S/Configuration_adv.h | 181 ++++++++---------- .../JGAurora/Magic/Configuration_adv.h | 181 ++++++++---------- .../examples/Kingroon/KP3/Configuration_adv.h | 181 ++++++++---------- .../Kingroon/KP3S/Configuration_adv.h | 181 ++++++++---------- .../Kingroon/KP3S_Pro/Configuration_adv.h | 181 ++++++++---------- .../Kingroon/KP5L-DIY/Configuration_adv.h | 181 ++++++++---------- .../examples/Labists/ET4/Configuration_adv.h | 181 ++++++++---------- .../examples/Longer/LK5/Configuration_adv.h | 181 ++++++++---------- .../examples/LulzBot/TAZ4/Configuration_adv.h | 181 ++++++++---------- config/examples/MBot/Cube/Configuration_adv.h | 181 ++++++++---------- .../MakerFarm/Pegasus 12/Configuration_adv.h | 181 ++++++++---------- .../examples/MakerParts/Configuration_adv.h | 181 ++++++++---------- .../Proforge2sDual/Configuration_adv.h | 181 ++++++++---------- .../examples/Malyan/M150/Configuration_adv.h | 181 ++++++++---------- .../examples/Malyan/M180/Configuration_adv.h | 181 ++++++++---------- .../examples/Malyan/M200/Configuration_adv.h | 181 ++++++++---------- .../Micromake/C1/basic/Configuration_adv.h | 181 ++++++++---------- .../Micromake/C1/enhanced/Configuration_adv.h | 181 ++++++++---------- config/examples/Mks/Robin/Configuration_adv.h | 181 ++++++++---------- .../Mks/Robin_Lite3/Configuration_adv.h | 181 ++++++++---------- .../Mks/Robin_Pro/Configuration_adv.h | 181 ++++++++---------- config/examples/Mks/Sbase/Configuration_adv.h | 181 ++++++++---------- .../examples/Modix/Big60/Configuration_adv.h | 181 ++++++++---------- config/examples/Nextion/Configuration_adv.h | 181 ++++++++---------- .../Hadron/Sanguinololu/Configuration_adv.h | 181 ++++++++---------- .../Opulo/Lumen_REV3/Configuration_adv.h | 181 ++++++++---------- .../Opulo/Lumen_REV4/Configuration_adv.h | 181 ++++++++---------- config/examples/Ortur 4/Configuration_adv.h | 181 ++++++++---------- .../examples/Polargraph/Configuration_adv.h | 181 ++++++++---------- .../PrintrboardG2/Configuration_adv.h | 181 ++++++++---------- .../Simple Metal RevD/Configuration_adv.h | 181 ++++++++---------- .../Simple_Metal_RevF6/Configuration_adv.h | 181 ++++++++---------- config/examples/Prusa/MK3/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../examples/Qidi/Qidi 1/Configuration_adv.h | 181 ++++++++---------- .../examples/Raiscube/A8r/Configuration_adv.h | 181 ++++++++---------- .../RapideLite/RL200/Configuration_adv.h | 181 ++++++++---------- .../Renkforce/RF100/Configuration_adv.h | 181 ++++++++---------- .../Renkforce/RF100XL/Configuration_adv.h | 181 ++++++++---------- .../Renkforce/RF100v2/Configuration_adv.h | 181 ++++++++---------- .../RepRapPro/Huxley/Configuration_adv.h | 181 ++++++++---------- .../Megatronics/Configuration_adv.h | 181 ++++++++---------- .../Minitronics20/CNC/Configuration_adv.h | 181 ++++++++---------- config/examples/RigidBot/Configuration_adv.h | 181 ++++++++---------- .../examples/Robo3D/R1+/Configuration_adv.h | 181 ++++++++---------- .../Rolohaun/Rook MK1/Configuration_adv.h | 181 ++++++++---------- .../SCARA/MP_SCARA/Configuration_adv.h | 181 ++++++++---------- .../examples/SCARA/Morgan/Configuration_adv.h | 181 ++++++++---------- .../Black_STM32F407VET6/Configuration_adv.h | 181 ++++++++---------- .../STM32/STM32F103RE/Configuration_adv.h | 181 ++++++++---------- .../Simax/Mi-M200/Configuration_adv.h | 181 ++++++++---------- config/examples/Simulator/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../SV-01/CrealityV22/Configuration_adv.h | 181 ++++++++---------- .../SV-01/CrealityV221/Configuration_adv.h | 181 ++++++++---------- .../examples/Sovol/SV-02/Configuration_adv.h | 181 ++++++++---------- .../examples/Sovol/SV-03/Configuration_adv.h | 181 ++++++++---------- .../examples/Sovol/SV-05/Configuration_adv.h | 181 ++++++++---------- .../examples/Sovol/SV-06/Configuration_adv.h | 181 ++++++++---------- config/examples/Sunlu/S8/Configuration_adv.h | 181 ++++++++---------- config/examples/Sunlu/T3/Configuration_adv.h | 181 ++++++++---------- .../TPARA/AXEL_TPARA/Configuration_adv.h | 181 ++++++++---------- .../Tevo/Michelangelo/Configuration_adv.h | 181 ++++++++---------- .../examples/Tevo/Nereus/Configuration_adv.h | 181 ++++++++---------- .../MKS Gen_L/Configuration_adv.h | 181 ++++++++---------- .../MKS SGen_L/Configuration_adv.h | 181 ++++++++---------- .../Tornado/V1 (MKS Base)/Configuration_adv.h | 181 ++++++++---------- .../V2 (MKS Gen_L)/Configuration_adv.h | 181 ++++++++---------- .../Ditto Pro/RAMPS 1.4/Configuration_adv.h | 181 ++++++++---------- config/examples/TinyBoy2/Configuration_adv.h | 181 ++++++++---------- .../CXY-v6-191017 board/Configuration_adv.h | 181 ++++++++---------- config/examples/Tronxy/X1/Configuration_adv.h | 181 ++++++++---------- .../examples/Tronxy/X3A/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../examples/Tronxy/X5S/Configuration_adv.h | 181 ++++++++---------- .../Tronxy/X5SA-2E/Configuration_adv.h | 181 ++++++++---------- .../examples/Tronxy/X5SA/Configuration_adv.h | 181 ++++++++---------- .../examples/Tronxy/XY100/Configuration_adv.h | 181 ++++++++---------- .../Tronxy/XY2-Pro/Configuration_adv.h | 181 ++++++++---------- .../Turnigy/Fabrikator/Configuration_adv.h | 181 ++++++++---------- .../Two Trees/BlueR Plus/Configuration_adv.h | 181 ++++++++---------- .../BlueR/BlueR V1/Configuration_adv.h | 181 ++++++++---------- .../BlueR/BlueR V2/Configuration_adv.h | 181 ++++++++---------- .../BlueR/BlueR V3/Configuration_adv.h | 181 ++++++++---------- .../Two Trees/SP-5_V3/Configuration_adv.h | 181 ++++++++---------- .../Sapphire Plus V2.1/Configuration_adv.h | 181 ++++++++---------- .../Sapphire Plus V2/Configuration_adv.h | 181 ++++++++---------- .../Sapphire Pro/Configuration_adv.h | 181 ++++++++---------- .../UltiMachine/Archim1/Configuration_adv.h | 181 ++++++++---------- .../UltiMachine/Archim2/Configuration_adv.h | 181 ++++++++---------- .../Ultimaker 2+/Configuration_adv.h | 181 ++++++++---------- .../Ultimaker/Ultimaker 2/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../examples/VORONDesign/Configuration_adv.h | 181 ++++++++---------- .../K8200 Upgraded/Configuration_adv.h | 181 ++++++++---------- .../Velleman/K8200/Configuration_adv.h | 181 ++++++++---------- .../K8400/Dual-head/Configuration_adv.h | 181 ++++++++---------- .../K8400/Single-head/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../WASP/PowerWASP/Configuration_adv.h | 181 ++++++++---------- .../Wanhao/Duplicator 4S/Configuration_adv.h | 181 ++++++++---------- .../Wanhao/Duplicator 6/Configuration_adv.h | 181 ++++++++---------- .../Duplicator i3 2.1/Configuration_adv.h | 181 ++++++++---------- .../Duplicator i3 Mini/Configuration_adv.h | 181 ++++++++---------- .../Duplicator i3 Plus/Configuration_adv.h | 181 ++++++++---------- .../Weedo/Tina2/V2/Configuration_adv.h | 181 ++++++++---------- .../Weedo/Tina2/V3/Configuration_adv.h | 181 ++++++++---------- .../Weistek/wt150/Configuration_adv.h | 181 ++++++++---------- .../Zonestar/P802M/Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Configuration_adv.h | 181 ++++++++---------- .../Kossel Linear Plus/Configuration_adv.h | 181 ++++++++---------- .../delta/Anycubic/Kossel/Configuration_adv.h | 181 ++++++++---------- .../Anycubic/Predator/Configuration_adv.h | 181 ++++++++---------- .../Dreammaker/Overlord/Configuration_adv.h | 181 ++++++++---------- .../Overlord_Pro/Configuration_adv.h | 181 ++++++++---------- .../FLSUN/Q5-nano_v1/Configuration_adv.h | 181 ++++++++---------- .../FLSUN/Q5-nano_v2/Configuration_adv.h | 181 ++++++++---------- .../delta/FLSUN/QQ-S/Configuration_adv.h | 181 ++++++++---------- .../delta/FLSUN/QQS-Pro/Configuration_adv.h | 181 ++++++++---------- .../FLSUN/auto_calibrate/Configuration_adv.h | 181 ++++++++---------- .../delta/FLSUN/kossel/Configuration_adv.h | 181 ++++++++---------- .../FLSUN/kossel_mini/Configuration_adv.h | 181 ++++++++---------- .../delta/Geeetech/G2/Configuration_adv.h | 181 ++++++++---------- .../delta/Geeetech/G2Pro/Configuration_adv.h | 181 ++++++++---------- .../delta/Geeetech/G2S/Configuration_adv.h | 181 ++++++++---------- .../delta/Geeetech/G2SPro/Configuration_adv.h | 181 ++++++++---------- .../Geeetech/Rostock 301/Configuration_adv.h | 181 ++++++++---------- .../delta/Hatchbox_Alpha/Configuration_adv.h | 181 ++++++++---------- .../delta/MKS/SBASE/Configuration_adv.h | 181 ++++++++---------- .../delta/Malyan M300/Configuration_adv.h | 181 ++++++++---------- .../Tevo Little Monster/Configuration_adv.h | 181 ++++++++---------- .../delta/Velleman/K8800/Configuration_adv.h | 181 ++++++++---------- .../delta/generic/Configuration_adv.h | 181 ++++++++---------- .../delta/kossel_clear/Configuration_adv.h | 181 ++++++++---------- .../delta/kossel_mini/Configuration_adv.h | 181 ++++++++---------- .../delta/kossel_pro/Configuration_adv.h | 181 ++++++++---------- .../delta/kossel_xl/Configuration_adv.h | 181 ++++++++---------- .../gCreate/gMax1.5+/Configuration_adv.h | 181 ++++++++---------- .../Octopus 8 LINEAR_AXES/Configuration_adv.h | 181 ++++++++---------- .../RAMPS 5 LINEAR_AXES/Configuration_adv.h | 181 ++++++++---------- config/examples/makibox/Configuration_adv.h | 181 ++++++++---------- .../tvrrug/Round2/Configuration_adv.h | 181 ++++++++---------- 376 files changed, 30080 insertions(+), 37976 deletions(-) diff --git a/config/default/Configuration_adv.h b/config/default/Configuration_adv.h index f7bd0a85d75..7c0a70578c9 100644 --- a/config/default/Configuration_adv.h +++ b/config/default/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/3DFabXYZ/Migbot/Configuration_adv.h b/config/examples/3DFabXYZ/Migbot/Configuration_adv.h index 3039cd1139b..69786d9e32f 100644 --- a/config/examples/3DFabXYZ/Migbot/Configuration_adv.h +++ b/config/examples/3DFabXYZ/Migbot/Configuration_adv.h @@ -4424,93 +4424,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4551,14 +4514,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4567,28 +4525,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4606,12 +4562,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4621,15 +4602,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/3DMatik/XL/Configuration_adv.h b/config/examples/3DMatik/XL/Configuration_adv.h index 4b9c4f3066d..45a0fb84034 100644 --- a/config/examples/3DMatik/XL/Configuration_adv.h +++ b/config/examples/3DMatik/XL/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/ADIMLab/Gantry v1/Configuration_adv.h b/config/examples/ADIMLab/Gantry v1/Configuration_adv.h index 2bae4c53eec..bc3bdf31ba0 100644 --- a/config/examples/ADIMLab/Gantry v1/Configuration_adv.h +++ b/config/examples/ADIMLab/Gantry v1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/ADIMLab/Gantry v2/Configuration_adv.h b/config/examples/ADIMLab/Gantry v2/Configuration_adv.h index 5a5ff348ec9..e34b00b7d61 100644 --- a/config/examples/ADIMLab/Gantry v2/Configuration_adv.h +++ b/config/examples/ADIMLab/Gantry v2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Alfawise/U20-bltouch/Configuration_adv.h b/config/examples/Alfawise/U20-bltouch/Configuration_adv.h index 38027b158d0..5a0d42a73ce 100644 --- a/config/examples/Alfawise/U20-bltouch/Configuration_adv.h +++ b/config/examples/Alfawise/U20-bltouch/Configuration_adv.h @@ -4438,93 +4438,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4565,14 +4528,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4581,28 +4539,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4620,12 +4576,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4635,15 +4616,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Alfawise/U20/Configuration_adv.h b/config/examples/Alfawise/U20/Configuration_adv.h index 41b108d8c8c..88ad6e31883 100644 --- a/config/examples/Alfawise/U20/Configuration_adv.h +++ b/config/examples/Alfawise/U20/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AliExpress/CL-260/Configuration_adv.h b/config/examples/AliExpress/CL-260/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/AliExpress/CL-260/Configuration_adv.h +++ b/config/examples/AliExpress/CL-260/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AliExpress/UM2pExt/Configuration_adv.h b/config/examples/AliExpress/UM2pExt/Configuration_adv.h index 5788879ddb3..4d352245551 100644 --- a/config/examples/AliExpress/UM2pExt/Configuration_adv.h +++ b/config/examples/AliExpress/UM2pExt/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A2/Configuration_adv.h b/config/examples/Anet/A2/Configuration_adv.h index 98322717591..c9975e09999 100644 --- a/config/examples/Anet/A2/Configuration_adv.h +++ b/config/examples/Anet/A2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A2plus/Configuration_adv.h b/config/examples/Anet/A2plus/Configuration_adv.h index 98322717591..c9975e09999 100644 --- a/config/examples/Anet/A2plus/Configuration_adv.h +++ b/config/examples/Anet/A2plus/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A6/Configuration_adv.h b/config/examples/Anet/A6/Configuration_adv.h index a03b5e0bbe0..e7864dc14b7 100644 --- a/config/examples/Anet/A6/Configuration_adv.h +++ b/config/examples/Anet/A6/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A8/Configuration_adv.h b/config/examples/Anet/A8/Configuration_adv.h index fb784f2508d..ae9675f273c 100644 --- a/config/examples/Anet/A8/Configuration_adv.h +++ b/config/examples/Anet/A8/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A8plus/Configuration_adv.h b/config/examples/Anet/A8plus/Configuration_adv.h index bbf853eaf1b..af3d69e8ac2 100644 --- a/config/examples/Anet/A8plus/Configuration_adv.h +++ b/config/examples/Anet/A8plus/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/A9/Configuration_adv.h b/config/examples/Anet/A9/Configuration_adv.h index d6d27b20b37..4bcd9fc84a8 100644 --- a/config/examples/Anet/A9/Configuration_adv.h +++ b/config/examples/Anet/A9/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/E10/Configuration_adv.h b/config/examples/Anet/E10/Configuration_adv.h index 3e1666daeec..e201ad9be1e 100644 --- a/config/examples/Anet/E10/Configuration_adv.h +++ b/config/examples/Anet/E10/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/E16/BTT SKR 1.3/Configuration_adv.h b/config/examples/Anet/E16/BTT SKR 1.3/Configuration_adv.h index f75d5652899..5f35f7e348f 100644 --- a/config/examples/Anet/E16/BTT SKR 1.3/Configuration_adv.h +++ b/config/examples/Anet/E16/BTT SKR 1.3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/E16/Stock/Configuration_adv.h b/config/examples/Anet/E16/Stock/Configuration_adv.h index fe44a91e743..9553ea13412 100644 --- a/config/examples/Anet/E16/Stock/Configuration_adv.h +++ b/config/examples/Anet/E16/Stock/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET4+/Configuration_adv.h b/config/examples/Anet/ET4+/Configuration_adv.h index 31eec17a2a4..ff99138035e 100644 --- a/config/examples/Anet/ET4+/Configuration_adv.h +++ b/config/examples/Anet/ET4+/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET4-Pro/Configuration_adv.h b/config/examples/Anet/ET4-Pro/Configuration_adv.h index 31eec17a2a4..ff99138035e 100644 --- a/config/examples/Anet/ET4-Pro/Configuration_adv.h +++ b/config/examples/Anet/ET4-Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET4/Configuration_adv.h b/config/examples/Anet/ET4/Configuration_adv.h index 31eec17a2a4..ff99138035e 100644 --- a/config/examples/Anet/ET4/Configuration_adv.h +++ b/config/examples/Anet/ET4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET4X/Configuration_adv.h b/config/examples/Anet/ET4X/Configuration_adv.h index 31eec17a2a4..ff99138035e 100644 --- a/config/examples/Anet/ET4X/Configuration_adv.h +++ b/config/examples/Anet/ET4X/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET5-Pro/Configuration_adv.h b/config/examples/Anet/ET5-Pro/Configuration_adv.h index dd56f770316..628204a4bd4 100644 --- a/config/examples/Anet/ET5-Pro/Configuration_adv.h +++ b/config/examples/Anet/ET5-Pro/Configuration_adv.h @@ -4425,93 +4425,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4552,14 +4515,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4568,28 +4526,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4607,12 +4563,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4622,15 +4603,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET5/Configuration_adv.h b/config/examples/Anet/ET5/Configuration_adv.h index dd56f770316..628204a4bd4 100644 --- a/config/examples/Anet/ET5/Configuration_adv.h +++ b/config/examples/Anet/ET5/Configuration_adv.h @@ -4425,93 +4425,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4552,14 +4515,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4568,28 +4526,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4607,12 +4563,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4622,15 +4603,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Anet/ET5X/Configuration_adv.h b/config/examples/Anet/ET5X/Configuration_adv.h index dd56f770316..628204a4bd4 100644 --- a/config/examples/Anet/ET5X/Configuration_adv.h +++ b/config/examples/Anet/ET5X/Configuration_adv.h @@ -4425,93 +4425,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4552,14 +4515,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4568,28 +4526,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4607,12 +4563,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4622,15 +4603,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/Chiron/Configuration_adv.h b/config/examples/AnyCubic/Chiron/Configuration_adv.h index 084d4d8c80d..075548b6c27 100644 --- a/config/examples/AnyCubic/Chiron/Configuration_adv.h +++ b/config/examples/AnyCubic/Chiron/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/Mega Zero 2.0/Anycubic V1/Configuration_adv.h b/config/examples/AnyCubic/Mega Zero 2.0/Anycubic V1/Configuration_adv.h index c3904323944..136852597f2 100644 --- a/config/examples/AnyCubic/Mega Zero 2.0/Anycubic V1/Configuration_adv.h +++ b/config/examples/AnyCubic/Mega Zero 2.0/Anycubic V1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/Mega Zero/Anycubic V1/Configuration_adv.h b/config/examples/AnyCubic/Mega Zero/Anycubic V1/Configuration_adv.h index 903375b9454..c4bc496f604 100644 --- a/config/examples/AnyCubic/Mega Zero/Anycubic V1/Configuration_adv.h +++ b/config/examples/AnyCubic/Mega Zero/Anycubic V1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/Mega Zero/BigTreeTech SKR Mini MZ V1.0/Configuration_adv.h b/config/examples/AnyCubic/Mega Zero/BigTreeTech SKR Mini MZ V1.0/Configuration_adv.h index bfaf71e671c..9002080c1dc 100644 --- a/config/examples/AnyCubic/Mega Zero/BigTreeTech SKR Mini MZ V1.0/Configuration_adv.h +++ b/config/examples/AnyCubic/Mega Zero/BigTreeTech SKR Mini MZ V1.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/Vyper/Configuration_adv.h b/config/examples/AnyCubic/Vyper/Configuration_adv.h index 88b1f192171..efe8726a978 100644 --- a/config/examples/AnyCubic/Vyper/Configuration_adv.h +++ b/config/examples/AnyCubic/Vyper/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/i3 Mega/Trigorilla AVR/Configuration_adv.h b/config/examples/AnyCubic/i3 Mega/Trigorilla AVR/Configuration_adv.h index dfcee09a26d..c8d773d5425 100644 --- a/config/examples/AnyCubic/i3 Mega/Trigorilla AVR/Configuration_adv.h +++ b/config/examples/AnyCubic/i3 Mega/Trigorilla AVR/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/i3 Mega/Trigorilla Pro STM32/Configuration_adv.h b/config/examples/AnyCubic/i3 Mega/Trigorilla Pro STM32/Configuration_adv.h index a216731a2e7..2ed0c840b4a 100644 --- a/config/examples/AnyCubic/i3 Mega/Trigorilla Pro STM32/Configuration_adv.h +++ b/config/examples/AnyCubic/i3 Mega/Trigorilla Pro STM32/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/AnyCubic/i3/Configuration_adv.h b/config/examples/AnyCubic/i3/Configuration_adv.h index a73f021599a..d88002f1020 100644 --- a/config/examples/AnyCubic/i3/Configuration_adv.h +++ b/config/examples/AnyCubic/i3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/ArmEd/Configuration_adv.h b/config/examples/ArmEd/Configuration_adv.h index 3003c43300b..557df204bdc 100644 --- a/config/examples/ArmEd/Configuration_adv.h +++ b/config/examples/ArmEd/Configuration_adv.h @@ -4433,93 +4433,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4560,14 +4523,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4576,28 +4534,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4615,12 +4571,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4630,15 +4611,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Genius Pro/Configuration_adv.h b/config/examples/Artillery/Genius Pro/Configuration_adv.h index 5c453cc4d71..88e12f11b1f 100644 --- a/config/examples/Artillery/Genius Pro/Configuration_adv.h +++ b/config/examples/Artillery/Genius Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Genius/BLTouch/Configuration_adv.h b/config/examples/Artillery/Genius/BLTouch/Configuration_adv.h index d07fd6b9eb1..a30e3a8bf8b 100644 --- a/config/examples/Artillery/Genius/BLTouch/Configuration_adv.h +++ b/config/examples/Artillery/Genius/BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Genius/V1/Configuration_adv.h b/config/examples/Artillery/Genius/V1/Configuration_adv.h index 22881ec7ca2..d7386e394b8 100644 --- a/config/examples/Artillery/Genius/V1/Configuration_adv.h +++ b/config/examples/Artillery/Genius/V1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Hornet/Configuration_adv.h b/config/examples/Artillery/Hornet/Configuration_adv.h index 834ded54a7c..2e55fac225a 100644 --- a/config/examples/Artillery/Hornet/Configuration_adv.h +++ b/config/examples/Artillery/Hornet/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Sidewinder X1/0.9 BMG - E3D V6/Configuration_adv.h b/config/examples/Artillery/Sidewinder X1/0.9 BMG - E3D V6/Configuration_adv.h index 0dbfad2d5d3..f80bab5f039 100644 --- a/config/examples/Artillery/Sidewinder X1/0.9 BMG - E3D V6/Configuration_adv.h +++ b/config/examples/Artillery/Sidewinder X1/0.9 BMG - E3D V6/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Sidewinder X1/V1/Configuration_adv.h b/config/examples/Artillery/Sidewinder X1/V1/Configuration_adv.h index 22881ec7ca2..d7386e394b8 100644 --- a/config/examples/Artillery/Sidewinder X1/V1/Configuration_adv.h +++ b/config/examples/Artillery/Sidewinder X1/V1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Artillery/Sidewinder X2/Configuration_adv.h b/config/examples/Artillery/Sidewinder X2/Configuration_adv.h index 33a35d9b76e..cc209eb3627 100644 --- a/config/examples/Artillery/Sidewinder X2/Configuration_adv.h +++ b/config/examples/Artillery/Sidewinder X2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Azteeg/X5GT/Configuration_adv.h b/config/examples/Azteeg/X5GT/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/Azteeg/X5GT/Configuration_adv.h +++ b/config/examples/Azteeg/X5GT/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h b/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h index 1ac23cea7cd..0c3ea09e7ff 100644 --- a/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h +++ b/config/examples/BIBO/TouchX/cyclops/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIBO/TouchX/default - BLTouch/Configuration_adv.h b/config/examples/BIBO/TouchX/default - BLTouch/Configuration_adv.h index 0ac7cc18db2..14ade88a47c 100644 --- a/config/examples/BIBO/TouchX/default - BLTouch/Configuration_adv.h +++ b/config/examples/BIBO/TouchX/default - BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIBO/TouchX/default/Configuration_adv.h b/config/examples/BIBO/TouchX/default/Configuration_adv.h index 4f6ea6b4e41..404cb68f4d1 100644 --- a/config/examples/BIBO/TouchX/default/Configuration_adv.h +++ b/config/examples/BIBO/TouchX/default/Configuration_adv.h @@ -4425,93 +4425,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4552,14 +4515,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4568,28 +4526,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4607,12 +4563,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4622,15 +4603,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/B1 SE Plus/Configuration_adv.h b/config/examples/BIQU/B1 SE Plus/Configuration_adv.h index 8edcbfbb92d..65a8604f60c 100644 --- a/config/examples/BIQU/B1 SE Plus/Configuration_adv.h +++ b/config/examples/BIQU/B1 SE Plus/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/B1 SE/Configuration_adv.h b/config/examples/BIQU/B1 SE/Configuration_adv.h index 4b699341c62..b6970bf6be0 100644 --- a/config/examples/BIQU/B1 SE/Configuration_adv.h +++ b/config/examples/BIQU/B1 SE/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/B1/Configuration_adv.h b/config/examples/BIQU/B1/Configuration_adv.h index d44cda77122..72d197f04c5 100644 --- a/config/examples/BIQU/B1/Configuration_adv.h +++ b/config/examples/BIQU/B1/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/BX/Configuration_adv.h b/config/examples/BIQU/BX/Configuration_adv.h index 14d62a94694..defb7621ab0 100644 --- a/config/examples/BIQU/BX/Configuration_adv.h +++ b/config/examples/BIQU/BX/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/Hurakan/Configuration_adv.h b/config/examples/BIQU/Hurakan/Configuration_adv.h index c0d70610499..39a819103a1 100644 --- a/config/examples/BIQU/Hurakan/Configuration_adv.h +++ b/config/examples/BIQU/Hurakan/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BIQU/Thunder Standard/Configuration_adv.h b/config/examples/BIQU/Thunder Standard/Configuration_adv.h index 37d5ca05da8..b9957e1bb99 100644 --- a/config/examples/BIQU/Thunder Standard/Configuration_adv.h +++ b/config/examples/BIQU/Thunder Standard/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BQ/Hephestos/Configuration_adv.h b/config/examples/BQ/Hephestos/Configuration_adv.h index d1d3e693e63..728b014b1cf 100644 --- a/config/examples/BQ/Hephestos/Configuration_adv.h +++ b/config/examples/BQ/Hephestos/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BQ/Hephestos_2/Configuration_adv.h b/config/examples/BQ/Hephestos_2/Configuration_adv.h index b76c8da1d03..f515daded24 100644 --- a/config/examples/BQ/Hephestos_2/Configuration_adv.h +++ b/config/examples/BQ/Hephestos_2/Configuration_adv.h @@ -4436,93 +4436,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4563,14 +4526,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4579,28 +4537,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4618,12 +4574,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4633,15 +4614,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/BQ/WITBOX/Configuration_adv.h b/config/examples/BQ/WITBOX/Configuration_adv.h index d1d3e693e63..728b014b1cf 100644 --- a/config/examples/BQ/WITBOX/Configuration_adv.h +++ b/config/examples/BQ/WITBOX/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/CNC/miniRambo/Configuration_adv.h b/config/examples/CNC/miniRambo/Configuration_adv.h index a8a234bec22..858dea660b3 100644 --- a/config/examples/CNC/miniRambo/Configuration_adv.h +++ b/config/examples/CNC/miniRambo/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/CTC/A13/Configuration_adv.h b/config/examples/CTC/A13/Configuration_adv.h index 93b9471f22c..e4e1502e1e6 100644 --- a/config/examples/CTC/A13/Configuration_adv.h +++ b/config/examples/CTC/A13/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/CTC/Bizer/Configuration_adv.h b/config/examples/CTC/Bizer/Configuration_adv.h index 763895e6d68..922308c9af3 100644 --- a/config/examples/CTC/Bizer/Configuration_adv.h +++ b/config/examples/CTC/Bizer/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/CTC/i3 2560 Rev A/no probe/Configuration_adv.h b/config/examples/CTC/i3 2560 Rev A/no probe/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/CTC/i3 2560 Rev A/no probe/Configuration_adv.h +++ b/config/examples/CTC/i3 2560 Rev A/no probe/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Cartesio/Configuration_adv.h b/config/examples/Cartesio/Configuration_adv.h index 48fb0a4bf9c..fff2fb48515 100644 --- a/config/examples/Cartesio/Configuration_adv.h +++ b/config/examples/Cartesio/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Copymaster3D/300/Configuration_adv.h b/config/examples/Copymaster3D/300/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/Copymaster3D/300/Configuration_adv.h +++ b/config/examples/Copymaster3D/300/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Copymaster3D/400/Configuration_adv.h b/config/examples/Copymaster3D/400/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/Copymaster3D/400/Configuration_adv.h +++ b/config/examples/Copymaster3D/400/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Copymaster3D/500/Configuration_adv.h b/config/examples/Copymaster3D/500/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/Copymaster3D/500/Configuration_adv.h +++ b/config/examples/Copymaster3D/500/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 Max/Configuration_adv.h b/config/examples/Creality/CR-10 Max/Configuration_adv.h index 7bb7d877b65..6a9cc72317e 100644 --- a/config/examples/Creality/CR-10 Max/Configuration_adv.h +++ b/config/examples/Creality/CR-10 Max/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index e2ddd33037d..0e4a2d341bd 100644 --- a/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index a1cdd38b135..9751311e280 100644 --- a/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10 Mini/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 Mini/CrealityV1/Configuration_adv.h b/config/examples/Creality/CR-10 Mini/CrealityV1/Configuration_adv.h index c87c9d6c9ef..aa2427f3065 100644 --- a/config/examples/Creality/CR-10 Mini/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/CR-10 Mini/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 Mini/MEEB-3DP/Configuration_adv.h b/config/examples/Creality/CR-10 Mini/MEEB-3DP/Configuration_adv.h index a7f48e69718..db81c5ddb06 100644 --- a/config/examples/Creality/CR-10 Mini/MEEB-3DP/Configuration_adv.h +++ b/config/examples/Creality/CR-10 Mini/MEEB-3DP/Configuration_adv.h @@ -4423,93 +4423,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4550,14 +4513,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4566,28 +4524,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4605,12 +4561,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4620,15 +4601,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S4/CrealityV1/Configuration_adv.h b/config/examples/Creality/CR-10 S4/CrealityV1/Configuration_adv.h index 7ab44685f2e..f8687a85593 100644 --- a/config/examples/Creality/CR-10 S4/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S4/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 1.2 with TFT35 E3 V3.0/Configuration_adv.h b/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 1.2 with TFT35 E3 V3.0/Configuration_adv.h index d9dfece5f77..367e06db34c 100644 --- a/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 1.2 with TFT35 E3 V3.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 1.2 with TFT35 E3 V3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 v3/Configuration_adv.h b/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 v3/Configuration_adv.h index a0d99dac20b..b0d87402041 100644 --- a/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 v3/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S5/BigTreeTech SKR Mini E3 v3/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S5/CrealityV1/Configuration_adv.h b/config/examples/Creality/CR-10 S5/CrealityV1/Configuration_adv.h index 7ab44685f2e..f8687a85593 100644 --- a/config/examples/Creality/CR-10 S5/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S5/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S5/CrealityV2.2 - BLTouch/Configuration_adv.h b/config/examples/Creality/CR-10 S5/CrealityV2.2 - BLTouch/Configuration_adv.h index 6e083942058..ffcde9c861d 100644 --- a/config/examples/Creality/CR-10 S5/CrealityV2.2 - BLTouch/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S5/CrealityV2.2 - BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 S5/CrealityV427 - BLTouch/Configuration_adv.h b/config/examples/Creality/CR-10 S5/CrealityV427 - BLTouch/Configuration_adv.h index 5988f1a9d01..fcadfc769cf 100644 --- a/config/examples/Creality/CR-10 S5/CrealityV427 - BLTouch/Configuration_adv.h +++ b/config/examples/Creality/CR-10 S5/CrealityV427 - BLTouch/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 V2/Configuration_adv.h b/config/examples/Creality/CR-10 V2/Configuration_adv.h index 51e20aa91ce..8423bbd8a59 100644 --- a/config/examples/Creality/CR-10 V2/Configuration_adv.h +++ b/config/examples/Creality/CR-10 V2/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10 V3/Configuration_adv.h b/config/examples/Creality/CR-10 V3/Configuration_adv.h index 314e92d488b..b809b00be78 100644 --- a/config/examples/Creality/CR-10 V3/Configuration_adv.h +++ b/config/examples/Creality/CR-10 V3/Configuration_adv.h @@ -4433,93 +4433,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4560,14 +4523,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4576,28 +4534,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4615,12 +4571,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4630,15 +4611,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 1a2eed0c68a..ded5412de2e 100644 --- a/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index 879351050b7..219f6fd9a42 100644 --- a/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10/CrealityV1/Configuration_adv.h b/config/examples/Creality/CR-10/CrealityV1/Configuration_adv.h index 073de7be216..5e31ec767c0 100644 --- a/config/examples/Creality/CR-10/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/CR-10/CrealityV1/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S Pro/Configuration_adv.h b/config/examples/Creality/CR-10S Pro/Configuration_adv.h index 4826d7eb021..aadd47d623f 100644 --- a/config/examples/Creality/CR-10S Pro/Configuration_adv.h +++ b/config/examples/Creality/CR-10S Pro/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/BigTreeTech SKR 1.4 Turbo TMC2209/Configuration_adv.h b/config/examples/Creality/CR-10S/BigTreeTech SKR 1.4 Turbo TMC2209/Configuration_adv.h index e75671db57d..f4f2f111feb 100644 --- a/config/examples/Creality/CR-10S/BigTreeTech SKR 1.4 Turbo TMC2209/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/BigTreeTech SKR 1.4 Turbo TMC2209/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/BigTreeTech SKR 2.0 TMC2209/Configuration_adv.h b/config/examples/Creality/CR-10S/BigTreeTech SKR 2.0 TMC2209/Configuration_adv.h index 04e4e26f5af..32510b8de92 100644 --- a/config/examples/Creality/CR-10S/BigTreeTech SKR 2.0 TMC2209/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/BigTreeTech SKR 2.0 TMC2209/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 1a2eed0c68a..ded5412de2e 100644 --- a/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index b0103f83f7c..1846e591cb3 100644 --- a/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/BigTreeTech SKR Pro v1.2/Configuration_adv.h b/config/examples/Creality/CR-10S/BigTreeTech SKR Pro v1.2/Configuration_adv.h index af3b608c923..d598d8de98e 100644 --- a/config/examples/Creality/CR-10S/BigTreeTech SKR Pro v1.2/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/BigTreeTech SKR Pro v1.2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/CrealityV1 - BLTouch/Configuration_adv.h b/config/examples/Creality/CR-10S/CrealityV1 - BLTouch/Configuration_adv.h index 5378a813490..bdd8b3ab977 100644 --- a/config/examples/Creality/CR-10S/CrealityV1 - BLTouch/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/CrealityV1 - BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-10S/CrealityV1/Configuration_adv.h b/config/examples/Creality/CR-10S/CrealityV1/Configuration_adv.h index d21631b7c91..983518fd9cf 100644 --- a/config/examples/Creality/CR-10S/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/CR-10S/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-20 Pro/Configuration_adv.h b/config/examples/Creality/CR-20 Pro/Configuration_adv.h index b16296a2178..00502889cde 100644 --- a/config/examples/Creality/CR-20 Pro/Configuration_adv.h +++ b/config/examples/Creality/CR-20 Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-20/RepRapWorld Minitronics20/Configuration_adv.h b/config/examples/Creality/CR-20/RepRapWorld Minitronics20/Configuration_adv.h index 91a6153e0cc..0623a624077 100644 --- a/config/examples/Creality/CR-20/RepRapWorld Minitronics20/Configuration_adv.h +++ b/config/examples/Creality/CR-20/RepRapWorld Minitronics20/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-20/Stock/Configuration_adv.h b/config/examples/Creality/CR-20/Stock/Configuration_adv.h index 91a6153e0cc..0623a624077 100644 --- a/config/examples/Creality/CR-20/Stock/Configuration_adv.h +++ b/config/examples/Creality/CR-20/Stock/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-30 PrintMill/Configuration_adv.h b/config/examples/Creality/CR-30 PrintMill/Configuration_adv.h index 3bbd1ba9bb5..59d3b9fbcdf 100644 --- a/config/examples/Creality/CR-30 PrintMill/Configuration_adv.h +++ b/config/examples/Creality/CR-30 PrintMill/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-6 SE/Configuration_adv.h b/config/examples/Creality/CR-6 SE/Configuration_adv.h index 9d83ae33ec0..69bf4afb8b2 100644 --- a/config/examples/Creality/CR-6 SE/Configuration_adv.h +++ b/config/examples/Creality/CR-6 SE/Configuration_adv.h @@ -4415,93 +4415,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4542,14 +4505,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4558,28 +4516,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4597,12 +4553,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4612,15 +4593,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/CR-8/Configuration_adv.h b/config/examples/Creality/CR-8/Configuration_adv.h index 18eb63d955b..84993b5c246 100644 --- a/config/examples/Creality/CR-8/Configuration_adv.h +++ b/config/examples/Creality/CR-8/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-2 Pro/CrealityV24S4/Configuration_adv.h b/config/examples/Creality/Ender-2 Pro/CrealityV24S4/Configuration_adv.h index 8325b06e317..e6e4ad1f2d3 100644 --- a/config/examples/Creality/Ender-2 Pro/CrealityV24S4/Configuration_adv.h +++ b/config/examples/Creality/Ender-2 Pro/CrealityV24S4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-2 Pro/CrealityV423/Configuration_adv.h b/config/examples/Creality/Ender-2 Pro/CrealityV423/Configuration_adv.h index f01e72a8c7a..3c74acfd1cd 100644 --- a/config/examples/Creality/Ender-2 Pro/CrealityV423/Configuration_adv.h +++ b/config/examples/Creality/Ender-2 Pro/CrealityV423/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-2/Configuration_adv.h b/config/examples/Creality/Ender-2/Configuration_adv.h index 0a766c37067..da2fa457853 100644 --- a/config/examples/Creality/Ender-2/Configuration_adv.h +++ b/config/examples/Creality/Ender-2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Max Neo/Configuration_adv.h b/config/examples/Creality/Ender-3 Max Neo/Configuration_adv.h index 6f842179a79..0a36074434a 100644 --- a/config/examples/Creality/Ender-3 Max Neo/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Max Neo/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Max/Configuration_adv.h b/config/examples/Creality/Ender-3 Max/Configuration_adv.h index eec8e7a5009..72e562c24e4 100644 --- a/config/examples/Creality/Ender-3 Max/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Max/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Neo/Configuration_adv.h b/config/examples/Creality/Ender-3 Neo/Configuration_adv.h index 7d5dd5064d6..6cf011b8eec 100644 --- a/config/examples/Creality/Ender-3 Neo/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Neo/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR 1.4 Turbo/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR 1.4 Turbo/Configuration_adv.h index f81f608c166..b65ff9aa977 100644 --- a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR 1.4 Turbo/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR 1.4 Turbo/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h index 2cdaa429ee0..6be2160c9b0 100644 --- a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h index 2cdaa429ee0..6be2160c9b0 100644 --- a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index aa692226a9d..9b1f2acf1c2 100644 --- a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index 7498fa71184..64070fe2689 100644 --- a/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/Creality free-runs/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/Creality free-runs/Configuration_adv.h index c5f40ff0c5c..5f4bcdc92ee 100644 --- a/config/examples/Creality/Ender-3 Pro/Creality free-runs/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/Creality free-runs/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/CrealityV1/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/CrealityV1/Configuration_adv.h index f888d354f69..eab2184e877 100644 --- a/config/examples/Creality/Ender-3 Pro/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/CrealityV422/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/CrealityV422/Configuration_adv.h index b6efba6f6be..e044cd785c9 100644 --- a/config/examples/Creality/Ender-3 Pro/CrealityV422/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/CrealityV422/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/CrealityV427 - BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/CrealityV427 - BLTouch/Configuration_adv.h index c6b21a0e91c..1ff256f71d9 100644 --- a/config/examples/Creality/Ender-3 Pro/CrealityV427 - BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/CrealityV427 - BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 Pro/CrealityV427/Configuration_adv.h b/config/examples/Creality/Ender-3 Pro/CrealityV427/Configuration_adv.h index 5672981b86b..ab9293c809e 100644 --- a/config/examples/Creality/Ender-3 Pro/CrealityV427/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 Pro/CrealityV427/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 S1 Plus/Configuration_adv.h b/config/examples/Creality/Ender-3 S1 Plus/Configuration_adv.h index 5664b125f1e..c3c34090270 100644 --- a/config/examples/Creality/Ender-3 S1 Plus/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 S1 Plus/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 S1 Pro/Configuration_adv.h b/config/examples/Creality/Ender-3 S1 Pro/Configuration_adv.h index 5664b125f1e..c3c34090270 100644 --- a/config/examples/Creality/Ender-3 S1 Pro/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 S1 Pro/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 S1/STM32F1/Configuration_adv.h b/config/examples/Creality/Ender-3 S1/STM32F1/Configuration_adv.h index a4e09514ba2..13e383e9ccf 100644 --- a/config/examples/Creality/Ender-3 S1/STM32F1/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 S1/STM32F1/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 S1/STM32F4/Configuration_adv.h b/config/examples/Creality/Ender-3 S1/STM32F4/Configuration_adv.h index a3a0b9b6942..7e48fc63e9a 100644 --- a/config/examples/Creality/Ender-3 S1/STM32F4/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 S1/STM32F4/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2 Neo/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/Ender-3 V2 Neo/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index 2dea45f478e..9e4590fbfb6 100644 --- a/config/examples/Creality/Ender-3 V2 Neo/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2 Neo/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2 Neo/CrealityV422/Configuration_adv.h b/config/examples/Creality/Ender-3 V2 Neo/CrealityV422/Configuration_adv.h index e6b87fc28d2..02ddc737fbb 100644 --- a/config/examples/Creality/Ender-3 V2 Neo/CrealityV422/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2 Neo/CrealityV422/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/CrealityUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/CrealityUI/Configuration_adv.h index f3d7a7d6cf6..0d267734214 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/CrealityUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/CrealityUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/MarlinUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/MarlinUI/Configuration_adv.h index 6bb546d1c72..52ae22c598d 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/MarlinUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR E3 Turbo/MarlinUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/CrealityUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/CrealityUI/Configuration_adv.h index 3918726fb60..8b42a8431d0 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/CrealityUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/CrealityUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/MarlinUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/MarlinUI/Configuration_adv.h index 4d4ac08e836..12c69214b96 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/MarlinUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 2.0/MarlinUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/CrealityUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/CrealityUI/Configuration_adv.h index 63a1f403fae..bb2a378d9c3 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/CrealityUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/CrealityUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/MarlinUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/MarlinUI/Configuration_adv.h index 1d7b5c379d9..7988183d73f 100644 --- a/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/MarlinUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/BigTreeTech SKR Mini E3 3.0/MarlinUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/CrealityV422/CrealityUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/CrealityV422/CrealityUI/Configuration_adv.h index 8ac5786d4fc..7027ce17018 100644 --- a/config/examples/Creality/Ender-3 V2/CrealityV422/CrealityUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/CrealityV422/CrealityUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/CrealityV422/MarlinUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/CrealityV422/MarlinUI/Configuration_adv.h index 1a717fe3b2b..c290275b075 100644 --- a/config/examples/Creality/Ender-3 V2/CrealityV422/MarlinUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/CrealityV422/MarlinUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/CrealityV427/CrealityUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/CrealityV427/CrealityUI/Configuration_adv.h index 1fc06bfc11d..b030421b5df 100644 --- a/config/examples/Creality/Ender-3 V2/CrealityV427/CrealityUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/CrealityV427/CrealityUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3 V2/CrealityV427/MarlinUI/Configuration_adv.h b/config/examples/Creality/Ender-3 V2/CrealityV427/MarlinUI/Configuration_adv.h index 15c9853b7e4..ed1f7bbd3d6 100644 --- a/config/examples/Creality/Ender-3 V2/CrealityV427/MarlinUI/Configuration_adv.h +++ b/config/examples/Creality/Ender-3 V2/CrealityV427/MarlinUI/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech E3 RRF/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech E3 RRF/Configuration_adv.h index dffd2230c67..cba70fd7877 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech E3 RRF/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech E3 RRF/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech Manta E3 EZ/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech Manta E3 EZ/Configuration_adv.h index 287bf7a5e6b..b6b3a63eeeb 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech Manta E3 EZ/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech Manta E3 EZ/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR 1.4/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR 1.4/Configuration_adv.h index f45ade8cc04..d1a24fc5941 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR 1.4/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR 1.4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/2-into-1 Hotend/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/2-into-1 Hotend/Configuration_adv.h index c265d9e3116..ed0cf6af67c 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/2-into-1 Hotend/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/2-into-1 Hotend/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Dual Z/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Dual Z/Configuration_adv.h index 2fd985fa52b..7a7bdf8daa2 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Dual Z/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Dual Z/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Single Extruder/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Single Extruder/Configuration_adv.h index c265d9e3116..ed0cf6af67c 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Single Extruder/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR E3 Turbo/Single Extruder/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR E3-DIP V1.1/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR E3-DIP V1.1/Configuration_adv.h index 3528fba78a1..8d57b533b9e 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR E3-DIP V1.1/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR E3-DIP V1.1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h index 28f04468577..8bdee14f768 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h index 28f04468577..8bdee14f768 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 2d802f75dc6..37412776861 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index 66a5f961664..052a2cb602e 100644 --- a/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/Creality free-runs/Configuration_adv.h b/config/examples/Creality/Ender-3/Creality free-runs/Configuration_adv.h index c5f40ff0c5c..5f4bcdc92ee 100644 --- a/config/examples/Creality/Ender-3/Creality free-runs/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/Creality free-runs/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/CrealityV1/Configuration_adv.h b/config/examples/Creality/Ender-3/CrealityV1/Configuration_adv.h index f888d354f69..eab2184e877 100644 --- a/config/examples/Creality/Ender-3/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/CrealityV422/Configuration_adv.h b/config/examples/Creality/Ender-3/CrealityV422/Configuration_adv.h index 627d0c53a84..39433d07539 100644 --- a/config/examples/Creality/Ender-3/CrealityV422/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/CrealityV422/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/CrealityV427/Configuration_adv.h b/config/examples/Creality/Ender-3/CrealityV427/Configuration_adv.h index 5672981b86b..ab9293c809e 100644 --- a/config/examples/Creality/Ender-3/CrealityV427/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/CrealityV427/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/BLTouch/Configuration_adv.h index 15a5b4ddd45..cf1b9b9fcaf 100644 --- a/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/base/Configuration_adv.h b/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/base/Configuration_adv.h index 15a5b4ddd45..cf1b9b9fcaf 100644 --- a/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/base/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/FYSETC Cheetah 1.2/base/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/FYSETC Cheetah 2.0/Configuration_adv.h b/config/examples/Creality/Ender-3/FYSETC Cheetah 2.0/Configuration_adv.h index 34fb5191668..96a000338dd 100644 --- a/config/examples/Creality/Ender-3/FYSETC Cheetah 2.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/FYSETC Cheetah 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/FYSETC Cheetah/BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-3/FYSETC Cheetah/BLTouch/Configuration_adv.h index 15a5b4ddd45..cf1b9b9fcaf 100644 --- a/config/examples/Creality/Ender-3/FYSETC Cheetah/BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/FYSETC Cheetah/BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/FYSETC Cheetah/base/Configuration_adv.h b/config/examples/Creality/Ender-3/FYSETC Cheetah/base/Configuration_adv.h index 15a5b4ddd45..cf1b9b9fcaf 100644 --- a/config/examples/Creality/Ender-3/FYSETC Cheetah/base/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/FYSETC Cheetah/base/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/MEEB-3DP/Configuration_adv.h b/config/examples/Creality/Ender-3/MEEB-3DP/Configuration_adv.h index f32c6df0a44..44aa251baee 100644 --- a/config/examples/Creality/Ender-3/MEEB-3DP/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/MEEB-3DP/Configuration_adv.h @@ -4423,93 +4423,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4550,14 +4513,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4566,28 +4524,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4605,12 +4561,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4620,15 +4601,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/MKS Robin E3/V1.0/Configuration_adv.h b/config/examples/Creality/Ender-3/MKS Robin E3/V1.0/Configuration_adv.h index 93cef21348b..771444c7029 100644 --- a/config/examples/Creality/Ender-3/MKS Robin E3/V1.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/MKS Robin E3/V1.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/MKS Robin E3/V1.1/Configuration_adv.h b/config/examples/Creality/Ender-3/MKS Robin E3/V1.1/Configuration_adv.h index d8d9091df66..0e22b750457 100644 --- a/config/examples/Creality/Ender-3/MKS Robin E3/V1.1/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/MKS Robin E3/V1.1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/MKS Robin E3P/Configuration_adv.h b/config/examples/Creality/Ender-3/MKS Robin E3P/Configuration_adv.h index dd59c62242d..789d94016d8 100644 --- a/config/examples/Creality/Ender-3/MKS Robin E3P/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/MKS Robin E3P/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-3/TH3D EZBoard Lite V2/Configuration_adv.h b/config/examples/Creality/Ender-3/TH3D EZBoard Lite V2/Configuration_adv.h index 3fa105ce1bb..776fb58f0f4 100644 --- a/config/examples/Creality/Ender-3/TH3D EZBoard Lite V2/Configuration_adv.h +++ b/config/examples/Creality/Ender-3/TH3D EZBoard Lite V2/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-4/Configuration_adv.h b/config/examples/Creality/Ender-4/Configuration_adv.h index 74736437b13..97137cea470 100644 --- a/config/examples/Creality/Ender-4/Configuration_adv.h +++ b/config/examples/Creality/Ender-4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Plus/BigTreeTech SKR 3/Configuration_adv.h b/config/examples/Creality/Ender-5 Plus/BigTreeTech SKR 3/Configuration_adv.h index 023182cf211..8266768678b 100644 --- a/config/examples/Creality/Ender-5 Plus/BigTreeTech SKR 3/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Plus/BigTreeTech SKR 3/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Plus/CrealityV1 (ORIGIN UI)/Configuration_adv.h b/config/examples/Creality/Ender-5 Plus/CrealityV1 (ORIGIN UI)/Configuration_adv.h index 81a57a0c150..f5b0a5ed885 100644 --- a/config/examples/Creality/Ender-5 Plus/CrealityV1 (ORIGIN UI)/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Plus/CrealityV1 (ORIGIN UI)/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Plus/CrealityV1 (RELOADED UI)/Configuration_adv.h b/config/examples/Creality/Ender-5 Plus/CrealityV1 (RELOADED UI)/Configuration_adv.h index 0c82a9834a7..c5f97e27412 100644 --- a/config/examples/Creality/Ender-5 Plus/CrealityV1 (RELOADED UI)/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Plus/CrealityV1 (RELOADED UI)/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR E3 Turbo/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR E3 Turbo/Configuration_adv.h index c73fd26a59c..af54da36eb2 100644 --- a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR E3 Turbo/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR E3 Turbo/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h index b2d09aff9e2..5b9dbaf556e 100644 --- a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 2.0 with BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 2.0 with BLTouch/Configuration_adv.h index d4380ff5ea1..7e3369b442f 100644 --- a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 2.0 with BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 2.0 with BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 3.0 with BLTouch-HighTemp/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 3.0 with BLTouch-HighTemp/Configuration_adv.h index f814f11611b..f4c8d28040f 100644 --- a/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 3.0 with BLTouch-HighTemp/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/BigTreeTech SKR Mini E3 3.0 with BLTouch-HighTemp/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/CrealityV1/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/CrealityV1/Configuration_adv.h index 6a193e78d70..400fece24db 100644 --- a/config/examples/Creality/Ender-5 Pro/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/CrealityV422/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/CrealityV422/Configuration_adv.h index 3a7b88785bb..d219d1dd9a4 100644 --- a/config/examples/Creality/Ender-5 Pro/CrealityV422/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/CrealityV422/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 Pro/CrealityV427/Configuration_adv.h b/config/examples/Creality/Ender-5 Pro/CrealityV427/Configuration_adv.h index dbe08bc6180..eb7e49fdd73 100644 --- a/config/examples/Creality/Ender-5 Pro/CrealityV427/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 Pro/CrealityV427/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5 S1/Configuration_adv.h b/config/examples/Creality/Ender-5 S1/Configuration_adv.h index 3cf79a856db..2562bb67233 100644 --- a/config/examples/Creality/Ender-5 S1/Configuration_adv.h +++ b/config/examples/Creality/Ender-5 S1/Configuration_adv.h @@ -4432,93 +4432,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4559,14 +4522,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4575,28 +4533,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4614,12 +4570,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4629,15 +4610,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo with BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo with BLTouch/Configuration_adv.h index c73fd26a59c..af54da36eb2 100644 --- a/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo with BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo with BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo/Configuration_adv.h b/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo/Configuration_adv.h index 6c476624934..9e795f543e9 100644 --- a/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/BigTreeTech SKR E3 Turbo/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h index 02d0827b6bd..65a51a6dc90 100644 --- a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 1.2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 25101171b6a..d2beabd1404 100644 --- a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 3.0 with BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 3.0 with BLTouch/Configuration_adv.h index 73eed9a38ff..90468b614b3 100644 --- a/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 3.0 with BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/BigTreeTech SKR Mini E3 3.0 with BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/Creality free-runs/Configuration_adv.h b/config/examples/Creality/Ender-5/Creality free-runs/Configuration_adv.h index 7ae32606ff2..36810c0f48b 100644 --- a/config/examples/Creality/Ender-5/Creality free-runs/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/Creality free-runs/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/CrealityV1/Configuration_adv.h b/config/examples/Creality/Ender-5/CrealityV1/Configuration_adv.h index 6c4185cfeea..d28cebb7b98 100644 --- a/config/examples/Creality/Ender-5/CrealityV1/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/CrealityV1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/CrealityV427 with BLTouch/Configuration_adv.h b/config/examples/Creality/Ender-5/CrealityV427 with BLTouch/Configuration_adv.h index daab52e5aee..50e6f9148f3 100644 --- a/config/examples/Creality/Ender-5/CrealityV427 with BLTouch/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/CrealityV427 with BLTouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-5/CrealityV427/Configuration_adv.h b/config/examples/Creality/Ender-5/CrealityV427/Configuration_adv.h index 77bbe9a890d..797338004a4 100644 --- a/config/examples/Creality/Ender-5/CrealityV427/Configuration_adv.h +++ b/config/examples/Creality/Ender-5/CrealityV427/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Creality/Ender-6/Configuration_adv.h b/config/examples/Creality/Ender-6/Configuration_adv.h index 115b49773c4..987b7f944af 100644 --- a/config/examples/Creality/Ender-6/Configuration_adv.h +++ b/config/examples/Creality/Ender-6/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Dagoma/Disco Ultimate/Configuration_adv.h b/config/examples/Dagoma/Disco Ultimate/Configuration_adv.h index 03a02c87c53..643cfd63ec3 100644 --- a/config/examples/Dagoma/Disco Ultimate/Configuration_adv.h +++ b/config/examples/Dagoma/Disco Ultimate/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Daycom/3DP-100/Configuration_adv.h b/config/examples/Daycom/3DP-100/Configuration_adv.h index 543e6603855..d517c47fd87 100644 --- a/config/examples/Daycom/3DP-100/Configuration_adv.h +++ b/config/examples/Daycom/3DP-100/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/EXP3D/Imprimante multifonction/Configuration_adv.h b/config/examples/EXP3D/Imprimante multifonction/Configuration_adv.h index 99625e8966d..f439bd45d39 100644 --- a/config/examples/EXP3D/Imprimante multifonction/Configuration_adv.h +++ b/config/examples/EXP3D/Imprimante multifonction/Configuration_adv.h @@ -4425,93 +4425,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4552,14 +4515,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4568,28 +4526,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4607,12 +4563,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4622,15 +4603,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/EasyThreeD/ET4000PLUS/Configuration_adv.h b/config/examples/EasyThreeD/ET4000PLUS/Configuration_adv.h index e6679e998bb..d08e3c907fb 100644 --- a/config/examples/EasyThreeD/ET4000PLUS/Configuration_adv.h +++ b/config/examples/EasyThreeD/ET4000PLUS/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Eazao/Zero/Configuration_adv.h b/config/examples/Eazao/Zero/Configuration_adv.h index de6265833a4..e340df2ac87 100644 --- a/config/examples/Eazao/Zero/Configuration_adv.h +++ b/config/examples/Eazao/Zero/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Einstart-S/Configuration_adv.h b/config/examples/Einstart-S/Configuration_adv.h index 66f5557f939..83a5433bae8 100644 --- a/config/examples/Einstart-S/Configuration_adv.h +++ b/config/examples/Einstart-S/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Elegoo/Neptune 2/Configuration_adv.h b/config/examples/Elegoo/Neptune 2/Configuration_adv.h index 1c1ce95e57e..9d80af199f4 100644 --- a/config/examples/Elegoo/Neptune 2/Configuration_adv.h +++ b/config/examples/Elegoo/Neptune 2/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Eryone/Thinker SE/Configuration_adv.h b/config/examples/Eryone/Thinker SE/Configuration_adv.h index e9c1690bb36..030a9ff4c67 100644 --- a/config/examples/Eryone/Thinker SE/Configuration_adv.h +++ b/config/examples/Eryone/Thinker SE/Configuration_adv.h @@ -4434,93 +4434,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4561,14 +4524,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4577,28 +4535,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4616,12 +4572,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4631,15 +4612,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Eryone/Thinker V2/Configuration_adv.h b/config/examples/Eryone/Thinker V2/Configuration_adv.h index 83e97d11f10..b411f9c37d5 100644 --- a/config/examples/Eryone/Thinker V2/Configuration_adv.h +++ b/config/examples/Eryone/Thinker V2/Configuration_adv.h @@ -4434,93 +4434,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4561,14 +4524,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4577,28 +4535,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4616,12 +4572,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4631,15 +4612,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FYSETC/AIO_II/Configuration_adv.h b/config/examples/FYSETC/AIO_II/Configuration_adv.h index 515501c22c9..5a635b50454 100644 --- a/config/examples/FYSETC/AIO_II/Configuration_adv.h +++ b/config/examples/FYSETC/AIO_II/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FYSETC/F6_13/Configuration_adv.h b/config/examples/FYSETC/F6_13/Configuration_adv.h index ad0ca3e80db..7ce2202ffd3 100644 --- a/config/examples/FYSETC/F6_13/Configuration_adv.h +++ b/config/examples/FYSETC/F6_13/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FYSETC/S6/Configuration_adv.h b/config/examples/FYSETC/S6/Configuration_adv.h index 6b00e6650b1..1c7ac5f47ed 100644 --- a/config/examples/FYSETC/S6/Configuration_adv.h +++ b/config/examples/FYSETC/S6/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Felix/DUAL/Configuration_adv.h b/config/examples/Felix/DUAL/Configuration_adv.h index 000c1e58583..cf43971af37 100644 --- a/config/examples/Felix/DUAL/Configuration_adv.h +++ b/config/examples/Felix/DUAL/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Felix/Single/Configuration_adv.h b/config/examples/Felix/Single/Configuration_adv.h index 000c1e58583..cf43971af37 100644 --- a/config/examples/Felix/Single/Configuration_adv.h +++ b/config/examples/Felix/Single/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FlashForge/Creator 2X/Configuration_adv.h b/config/examples/FlashForge/Creator 2X/Configuration_adv.h index 2cd1d5793cc..67b48a67cc7 100644 --- a/config/examples/FlashForge/Creator 2X/Configuration_adv.h +++ b/config/examples/FlashForge/Creator 2X/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FlashForge/CreatorPro/Configuration_adv.h b/config/examples/FlashForge/CreatorPro/Configuration_adv.h index 8c9b1f509fb..b3ea9889d22 100644 --- a/config/examples/FlashForge/CreatorPro/Configuration_adv.h +++ b/config/examples/FlashForge/CreatorPro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FlyingBear/P902/Configuration_adv.h b/config/examples/FlyingBear/P902/Configuration_adv.h index 646bf3b0861..9d7aa78e908 100644 --- a/config/examples/FlyingBear/P902/Configuration_adv.h +++ b/config/examples/FlyingBear/P902/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FlyingBear/P905H/Configuration_adv.h b/config/examples/FlyingBear/P905H/Configuration_adv.h index d1bdb201e68..c738b6062f8 100644 --- a/config/examples/FlyingBear/P905H/Configuration_adv.h +++ b/config/examples/FlyingBear/P905H/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FoamCutter/generic/Configuration_adv.h b/config/examples/FoamCutter/generic/Configuration_adv.h index b9930211c80..76600623197 100644 --- a/config/examples/FoamCutter/generic/Configuration_adv.h +++ b/config/examples/FoamCutter/generic/Configuration_adv.h @@ -4436,93 +4436,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4563,14 +4526,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4579,28 +4537,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4618,12 +4574,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4633,15 +4614,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FoamCutter/rcKeith/Configuration_adv.h b/config/examples/FoamCutter/rcKeith/Configuration_adv.h index b9930211c80..76600623197 100644 --- a/config/examples/FoamCutter/rcKeith/Configuration_adv.h +++ b/config/examples/FoamCutter/rcKeith/Configuration_adv.h @@ -4436,93 +4436,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4563,14 +4526,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4579,28 +4537,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4618,12 +4574,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4633,15 +4614,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FolgerTech/FT-5 R2/Configuration_adv.h b/config/examples/FolgerTech/FT-5 R2/Configuration_adv.h index f244dfc1520..eb60e9bad30 100644 --- a/config/examples/FolgerTech/FT-5 R2/Configuration_adv.h +++ b/config/examples/FolgerTech/FT-5 R2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/FolgerTech/i3-2020/Configuration_adv.h b/config/examples/FolgerTech/i3-2020/Configuration_adv.h index 7d9cb04546c..620e9f97d36 100644 --- a/config/examples/FolgerTech/i3-2020/Configuration_adv.h +++ b/config/examples/FolgerTech/i3-2020/Configuration_adv.h @@ -4436,93 +4436,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4563,14 +4526,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4579,28 +4537,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4618,12 +4574,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4633,15 +4614,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Formbot/Raptor/Configuration_adv.h b/config/examples/Formbot/Raptor/Configuration_adv.h index ad17765aeb1..2775d2508e3 100644 --- a/config/examples/Formbot/Raptor/Configuration_adv.h +++ b/config/examples/Formbot/Raptor/Configuration_adv.h @@ -4433,93 +4433,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4560,14 +4523,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4576,28 +4534,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4615,12 +4571,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4630,15 +4611,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10/Configuration_adv.h b/config/examples/Geeetech/A10/Configuration_adv.h index b26696d7ccf..380d396bb43 100644 --- a/config/examples/Geeetech/A10/Configuration_adv.h +++ b/config/examples/Geeetech/A10/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10D/Configuration_adv.h b/config/examples/Geeetech/A10D/Configuration_adv.h index 43826b112fa..ae468fa7ced 100644 --- a/config/examples/Geeetech/A10D/Configuration_adv.h +++ b/config/examples/Geeetech/A10D/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10M/Stock LCD/Configuration_adv.h b/config/examples/Geeetech/A10M/Stock LCD/Configuration_adv.h index bbbdfca17dd..d0042887933 100644 --- a/config/examples/Geeetech/A10M/Stock LCD/Configuration_adv.h +++ b/config/examples/Geeetech/A10M/Stock LCD/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10M/YHCB2004_V4.1/Configuration_adv.h b/config/examples/Geeetech/A10M/YHCB2004_V4.1/Configuration_adv.h index bbbdfca17dd..d0042887933 100644 --- a/config/examples/Geeetech/A10M/YHCB2004_V4.1/Configuration_adv.h +++ b/config/examples/Geeetech/A10M/YHCB2004_V4.1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10PRO/Configuration_adv.h b/config/examples/Geeetech/A10PRO/Configuration_adv.h index b26696d7ccf..380d396bb43 100644 --- a/config/examples/Geeetech/A10PRO/Configuration_adv.h +++ b/config/examples/Geeetech/A10PRO/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10T/Stock LCD/Configuration_adv.h b/config/examples/Geeetech/A10T/Stock LCD/Configuration_adv.h index bbbdfca17dd..d0042887933 100644 --- a/config/examples/Geeetech/A10T/Stock LCD/Configuration_adv.h +++ b/config/examples/Geeetech/A10T/Stock LCD/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A10T/YHCB2004_V4.1/Configuration_adv.h b/config/examples/Geeetech/A10T/YHCB2004_V4.1/Configuration_adv.h index bbbdfca17dd..d0042887933 100644 --- a/config/examples/Geeetech/A10T/YHCB2004_V4.1/Configuration_adv.h +++ b/config/examples/Geeetech/A10T/YHCB2004_V4.1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A20/Configuration_adv.h b/config/examples/Geeetech/A20/Configuration_adv.h index d23a0b28a1a..e69ca9b0076 100644 --- a/config/examples/Geeetech/A20/Configuration_adv.h +++ b/config/examples/Geeetech/A20/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A20M/Configuration_adv.h b/config/examples/Geeetech/A20M/Configuration_adv.h index d23a0b28a1a..e69ca9b0076 100644 --- a/config/examples/Geeetech/A20M/Configuration_adv.h +++ b/config/examples/Geeetech/A20M/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A20T/Configuration_adv.h b/config/examples/Geeetech/A20T/Configuration_adv.h index d23a0b28a1a..e69ca9b0076 100644 --- a/config/examples/Geeetech/A20T/Configuration_adv.h +++ b/config/examples/Geeetech/A20T/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A30/Configuration_adv.h b/config/examples/Geeetech/A30/Configuration_adv.h index 3441663f8ac..111b7982fb9 100644 --- a/config/examples/Geeetech/A30/Configuration_adv.h +++ b/config/examples/Geeetech/A30/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A30M/Configuration_adv.h b/config/examples/Geeetech/A30M/Configuration_adv.h index 3441663f8ac..111b7982fb9 100644 --- a/config/examples/Geeetech/A30M/Configuration_adv.h +++ b/config/examples/Geeetech/A30M/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/A30T/Configuration_adv.h b/config/examples/Geeetech/A30T/Configuration_adv.h index 3441663f8ac..111b7982fb9 100644 --- a/config/examples/Geeetech/A30T/Configuration_adv.h +++ b/config/examples/Geeetech/A30T/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/D200/Configuration_adv.h b/config/examples/Geeetech/D200/Configuration_adv.h index 1f82f92940a..e2c8c8b42d2 100644 --- a/config/examples/Geeetech/D200/Configuration_adv.h +++ b/config/examples/Geeetech/D200/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Duplicator5/Configuration_adv.h b/config/examples/Geeetech/Duplicator5/Configuration_adv.h index 6b00e6650b1..1c7ac5f47ed 100644 --- a/config/examples/Geeetech/Duplicator5/Configuration_adv.h +++ b/config/examples/Geeetech/Duplicator5/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/E180/Configuration_adv.h b/config/examples/Geeetech/E180/Configuration_adv.h index 3441663f8ac..111b7982fb9 100644 --- a/config/examples/Geeetech/E180/Configuration_adv.h +++ b/config/examples/Geeetech/E180/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/GT2560/Configuration_adv.h b/config/examples/Geeetech/GT2560/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Geeetech/GT2560/Configuration_adv.h +++ b/config/examples/Geeetech/GT2560/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/I3_Pro_X-GT2560/Configuration_adv.h b/config/examples/Geeetech/I3_Pro_X-GT2560/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Geeetech/I3_Pro_X-GT2560/Configuration_adv.h +++ b/config/examples/Geeetech/I3_Pro_X-GT2560/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/M201/Configuration_adv.h b/config/examples/Geeetech/M201/Configuration_adv.h index 1f82f92940a..e2c8c8b42d2 100644 --- a/config/examples/Geeetech/M201/Configuration_adv.h +++ b/config/examples/Geeetech/M201/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/MeCreator2/Configuration_adv.h b/config/examples/Geeetech/MeCreator2/Configuration_adv.h index beac59f6122..dbddd0ce914 100644 --- a/config/examples/Geeetech/MeCreator2/Configuration_adv.h +++ b/config/examples/Geeetech/MeCreator2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Me_creator/Configuration_adv.h b/config/examples/Geeetech/Me_creator/Configuration_adv.h index 6b00e6650b1..1c7ac5f47ed 100644 --- a/config/examples/Geeetech/Me_creator/Configuration_adv.h +++ b/config/examples/Geeetech/Me_creator/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Me_ducer/Configuration_adv.h b/config/examples/Geeetech/Me_ducer/Configuration_adv.h index 9464af70842..7e8ef59be0e 100644 --- a/config/examples/Geeetech/Me_ducer/Configuration_adv.h +++ b/config/examples/Geeetech/Me_ducer/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/PI3A PRO/Configuration_adv.h b/config/examples/Geeetech/PI3A PRO/Configuration_adv.h index 02860810331..ef1e83ef58e 100644 --- a/config/examples/Geeetech/PI3A PRO/Configuration_adv.h +++ b/config/examples/Geeetech/PI3A PRO/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Prusa i3 Pro B/bltouch/Configuration_adv.h b/config/examples/Geeetech/Prusa i3 Pro B/bltouch/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Geeetech/Prusa i3 Pro B/bltouch/Configuration_adv.h +++ b/config/examples/Geeetech/Prusa i3 Pro B/bltouch/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Prusa i3 Pro B/noprobe/Configuration_adv.h b/config/examples/Geeetech/Prusa i3 Pro B/noprobe/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Geeetech/Prusa i3 Pro B/noprobe/Configuration_adv.h +++ b/config/examples/Geeetech/Prusa i3 Pro B/noprobe/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h b/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h index b26696d7ccf..380d396bb43 100644 --- a/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h +++ b/config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h b/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h index b26696d7ccf..380d396bb43 100644 --- a/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h +++ b/config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/HMS434/Configuration_adv.h b/config/examples/HMS434/Configuration_adv.h index 0ff66e792c8..58a71bd1e5d 100644 --- a/config/examples/HMS434/Configuration_adv.h +++ b/config/examples/HMS434/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Hictop/3DP-17/Configuration_adv.h b/config/examples/Hictop/3DP-17/Configuration_adv.h index 5f350f3fb72..6c8a3cfde86 100644 --- a/config/examples/Hictop/3DP-17/Configuration_adv.h +++ b/config/examples/Hictop/3DP-17/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Infitary/i3-M508/Configuration_adv.h b/config/examples/Infitary/i3-M508/Configuration_adv.h index 3550c6e954d..945b2879bf7 100644 --- a/config/examples/Infitary/i3-M508/Configuration_adv.h +++ b/config/examples/Infitary/i3-M508/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Intamsys/FunmatHT 4988/Configuration_adv.h b/config/examples/Intamsys/FunmatHT 4988/Configuration_adv.h index e392680c30d..ec747dfe7ca 100644 --- a/config/examples/Intamsys/FunmatHT 4988/Configuration_adv.h +++ b/config/examples/Intamsys/FunmatHT 4988/Configuration_adv.h @@ -4424,93 +4424,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4551,14 +4514,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4567,28 +4525,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4606,12 +4562,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4621,15 +4602,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/JGAurora/A1/Configuration_adv.h b/config/examples/JGAurora/A1/Configuration_adv.h index e038368e855..db287ffe66e 100644 --- a/config/examples/JGAurora/A1/Configuration_adv.h +++ b/config/examples/JGAurora/A1/Configuration_adv.h @@ -4434,93 +4434,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4561,14 +4524,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4577,28 +4535,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4616,12 +4572,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4631,15 +4612,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/JGAurora/A3/Configuration_adv.h b/config/examples/JGAurora/A3/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/JGAurora/A3/Configuration_adv.h +++ b/config/examples/JGAurora/A3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/JGAurora/A5/Configuration_adv.h b/config/examples/JGAurora/A5/Configuration_adv.h index 42fcf0e391d..4b522ee629d 100644 --- a/config/examples/JGAurora/A5/Configuration_adv.h +++ b/config/examples/JGAurora/A5/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/JGAurora/A5S/Configuration_adv.h b/config/examples/JGAurora/A5S/Configuration_adv.h index 8f5771d58ea..78a201eba6e 100644 --- a/config/examples/JGAurora/A5S/Configuration_adv.h +++ b/config/examples/JGAurora/A5S/Configuration_adv.h @@ -4434,93 +4434,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4561,14 +4524,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4577,28 +4535,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4616,12 +4572,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4631,15 +4612,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/JGAurora/Magic/Configuration_adv.h b/config/examples/JGAurora/Magic/Configuration_adv.h index ff36d645271..d0104c0f697 100644 --- a/config/examples/JGAurora/Magic/Configuration_adv.h +++ b/config/examples/JGAurora/Magic/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Kingroon/KP3/Configuration_adv.h b/config/examples/Kingroon/KP3/Configuration_adv.h index 1716843fe5d..344a584e94f 100644 --- a/config/examples/Kingroon/KP3/Configuration_adv.h +++ b/config/examples/Kingroon/KP3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Kingroon/KP3S/Configuration_adv.h b/config/examples/Kingroon/KP3S/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Kingroon/KP3S/Configuration_adv.h +++ b/config/examples/Kingroon/KP3S/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Kingroon/KP3S_Pro/Configuration_adv.h b/config/examples/Kingroon/KP3S_Pro/Configuration_adv.h index 4df99f9052d..bd4e86c07f7 100644 --- a/config/examples/Kingroon/KP3S_Pro/Configuration_adv.h +++ b/config/examples/Kingroon/KP3S_Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Kingroon/KP5L-DIY/Configuration_adv.h b/config/examples/Kingroon/KP5L-DIY/Configuration_adv.h index 57eecf9e720..bf8a8e63b6c 100644 --- a/config/examples/Kingroon/KP5L-DIY/Configuration_adv.h +++ b/config/examples/Kingroon/KP5L-DIY/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Labists/ET4/Configuration_adv.h b/config/examples/Labists/ET4/Configuration_adv.h index d67ffedb10e..c00ea20bf40 100644 --- a/config/examples/Labists/ET4/Configuration_adv.h +++ b/config/examples/Labists/ET4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Longer/LK5/Configuration_adv.h b/config/examples/Longer/LK5/Configuration_adv.h index 25c99f3403b..74bfb75a254 100644 --- a/config/examples/Longer/LK5/Configuration_adv.h +++ b/config/examples/Longer/LK5/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/LulzBot/TAZ4/Configuration_adv.h b/config/examples/LulzBot/TAZ4/Configuration_adv.h index 6b0124f0dfa..bcf4ca66fb6 100644 --- a/config/examples/LulzBot/TAZ4/Configuration_adv.h +++ b/config/examples/LulzBot/TAZ4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/MBot/Cube/Configuration_adv.h b/config/examples/MBot/Cube/Configuration_adv.h index dc33904921a..c98813e351c 100644 --- a/config/examples/MBot/Cube/Configuration_adv.h +++ b/config/examples/MBot/Cube/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/MakerFarm/Pegasus 12/Configuration_adv.h b/config/examples/MakerFarm/Pegasus 12/Configuration_adv.h index 74e3e8097c9..a3747813c62 100644 --- a/config/examples/MakerFarm/Pegasus 12/Configuration_adv.h +++ b/config/examples/MakerFarm/Pegasus 12/Configuration_adv.h @@ -4423,93 +4423,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4550,14 +4513,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4566,28 +4524,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4605,12 +4561,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4620,15 +4601,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/MakerParts/Configuration_adv.h b/config/examples/MakerParts/Configuration_adv.h index dda76c35378..43574250336 100644 --- a/config/examples/MakerParts/Configuration_adv.h +++ b/config/examples/MakerParts/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/MakerTech3D/Proforge2sDual/Configuration_adv.h b/config/examples/MakerTech3D/Proforge2sDual/Configuration_adv.h index 36cb442c2a9..3328d40d73e 100644 --- a/config/examples/MakerTech3D/Proforge2sDual/Configuration_adv.h +++ b/config/examples/MakerTech3D/Proforge2sDual/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Malyan/M150/Configuration_adv.h b/config/examples/Malyan/M150/Configuration_adv.h index a367f8280c2..dc25d6e8e20 100644 --- a/config/examples/Malyan/M150/Configuration_adv.h +++ b/config/examples/Malyan/M150/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Malyan/M180/Configuration_adv.h b/config/examples/Malyan/M180/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Malyan/M180/Configuration_adv.h +++ b/config/examples/Malyan/M180/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Malyan/M200/Configuration_adv.h b/config/examples/Malyan/M200/Configuration_adv.h index a60da693abc..64153e21748 100644 --- a/config/examples/Malyan/M200/Configuration_adv.h +++ b/config/examples/Malyan/M200/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Micromake/C1/basic/Configuration_adv.h b/config/examples/Micromake/C1/basic/Configuration_adv.h index 6d7919078d5..055e1a753f4 100644 --- a/config/examples/Micromake/C1/basic/Configuration_adv.h +++ b/config/examples/Micromake/C1/basic/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Micromake/C1/enhanced/Configuration_adv.h b/config/examples/Micromake/C1/enhanced/Configuration_adv.h index 27fd805746c..69d0ab6cb57 100644 --- a/config/examples/Micromake/C1/enhanced/Configuration_adv.h +++ b/config/examples/Micromake/C1/enhanced/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Mks/Robin/Configuration_adv.h b/config/examples/Mks/Robin/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Mks/Robin/Configuration_adv.h +++ b/config/examples/Mks/Robin/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Mks/Robin_Lite3/Configuration_adv.h b/config/examples/Mks/Robin_Lite3/Configuration_adv.h index c7f0f2f8c7d..9ea7490f968 100644 --- a/config/examples/Mks/Robin_Lite3/Configuration_adv.h +++ b/config/examples/Mks/Robin_Lite3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Mks/Robin_Pro/Configuration_adv.h b/config/examples/Mks/Robin_Pro/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Mks/Robin_Pro/Configuration_adv.h +++ b/config/examples/Mks/Robin_Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Mks/Sbase/Configuration_adv.h b/config/examples/Mks/Sbase/Configuration_adv.h index 67d00e0e5bb..47aab024f30 100644 --- a/config/examples/Mks/Sbase/Configuration_adv.h +++ b/config/examples/Mks/Sbase/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Modix/Big60/Configuration_adv.h b/config/examples/Modix/Big60/Configuration_adv.h index b1b26df3f6e..734a6375f6c 100644 --- a/config/examples/Modix/Big60/Configuration_adv.h +++ b/config/examples/Modix/Big60/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Nextion/Configuration_adv.h b/config/examples/Nextion/Configuration_adv.h index e7be1d6945d..5a549ab88e7 100644 --- a/config/examples/Nextion/Configuration_adv.h +++ b/config/examples/Nextion/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/ORD Bot/Hadron/Sanguinololu/Configuration_adv.h b/config/examples/ORD Bot/Hadron/Sanguinololu/Configuration_adv.h index 26fe3ea6491..922417fd0ab 100644 --- a/config/examples/ORD Bot/Hadron/Sanguinololu/Configuration_adv.h +++ b/config/examples/ORD Bot/Hadron/Sanguinololu/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Opulo/Lumen_REV3/Configuration_adv.h b/config/examples/Opulo/Lumen_REV3/Configuration_adv.h index 033ff1a0aae..d35c9a2279b 100644 --- a/config/examples/Opulo/Lumen_REV3/Configuration_adv.h +++ b/config/examples/Opulo/Lumen_REV3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Opulo/Lumen_REV4/Configuration_adv.h b/config/examples/Opulo/Lumen_REV4/Configuration_adv.h index 5972047df5b..9e356afb168 100644 --- a/config/examples/Opulo/Lumen_REV4/Configuration_adv.h +++ b/config/examples/Opulo/Lumen_REV4/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ortur 4/Configuration_adv.h b/config/examples/Ortur 4/Configuration_adv.h index 2ad309de819..9c2061c8e63 100644 --- a/config/examples/Ortur 4/Configuration_adv.h +++ b/config/examples/Ortur 4/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Polargraph/Configuration_adv.h b/config/examples/Polargraph/Configuration_adv.h index 21eb81a61ee..388c85020c0 100644 --- a/config/examples/Polargraph/Configuration_adv.h +++ b/config/examples/Polargraph/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Printrbot/PrintrboardG2/Configuration_adv.h b/config/examples/Printrbot/PrintrboardG2/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Printrbot/PrintrboardG2/Configuration_adv.h +++ b/config/examples/Printrbot/PrintrboardG2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Printrbot/Simple Metal RevD/Configuration_adv.h b/config/examples/Printrbot/Simple Metal RevD/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Printrbot/Simple Metal RevD/Configuration_adv.h +++ b/config/examples/Printrbot/Simple Metal RevD/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Printrbot/Simple_Metal_RevF6/Configuration_adv.h b/config/examples/Printrbot/Simple_Metal_RevF6/Configuration_adv.h index 56e15a2c2f2..88948919e42 100644 --- a/config/examples/Printrbot/Simple_Metal_RevF6/Configuration_adv.h +++ b/config/examples/Printrbot/Simple_Metal_RevF6/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Prusa/MK3/Configuration_adv.h b/config/examples/Prusa/MK3/Configuration_adv.h index c789afe6f94..8c62c161395 100644 --- a/config/examples/Prusa/MK3/Configuration_adv.h +++ b/config/examples/Prusa/MK3/Configuration_adv.h @@ -4434,93 +4434,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4561,14 +4524,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4577,28 +4535,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4616,12 +4572,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4631,15 +4612,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Prusa/MK3S-BigTreeTech-BTT002/Configuration_adv.h b/config/examples/Prusa/MK3S-BigTreeTech-BTT002/Configuration_adv.h index d793373790b..1602d8afd53 100644 --- a/config/examples/Prusa/MK3S-BigTreeTech-BTT002/Configuration_adv.h +++ b/config/examples/Prusa/MK3S-BigTreeTech-BTT002/Configuration_adv.h @@ -4433,93 +4433,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4560,14 +4523,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4576,28 +4534,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4615,12 +4571,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4630,15 +4611,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Qidi/Qidi 1/Configuration_adv.h b/config/examples/Qidi/Qidi 1/Configuration_adv.h index a7e443c7648..e09b5a7dacb 100644 --- a/config/examples/Qidi/Qidi 1/Configuration_adv.h +++ b/config/examples/Qidi/Qidi 1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Raiscube/A8r/Configuration_adv.h b/config/examples/Raiscube/A8r/Configuration_adv.h index b32b076d6f9..dd371b66390 100644 --- a/config/examples/Raiscube/A8r/Configuration_adv.h +++ b/config/examples/Raiscube/A8r/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/RapideLite/RL200/Configuration_adv.h b/config/examples/RapideLite/RL200/Configuration_adv.h index 6b00e6650b1..1c7ac5f47ed 100644 --- a/config/examples/RapideLite/RL200/Configuration_adv.h +++ b/config/examples/RapideLite/RL200/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Renkforce/RF100/Configuration_adv.h b/config/examples/Renkforce/RF100/Configuration_adv.h index 1c05f34bed7..ff4d42c5a68 100644 --- a/config/examples/Renkforce/RF100/Configuration_adv.h +++ b/config/examples/Renkforce/RF100/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Renkforce/RF100XL/Configuration_adv.h b/config/examples/Renkforce/RF100XL/Configuration_adv.h index 1c05f34bed7..ff4d42c5a68 100644 --- a/config/examples/Renkforce/RF100XL/Configuration_adv.h +++ b/config/examples/Renkforce/RF100XL/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Renkforce/RF100v2/Configuration_adv.h b/config/examples/Renkforce/RF100v2/Configuration_adv.h index 1c05f34bed7..ff4d42c5a68 100644 --- a/config/examples/Renkforce/RF100v2/Configuration_adv.h +++ b/config/examples/Renkforce/RF100v2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/RepRapPro/Huxley/Configuration_adv.h b/config/examples/RepRapPro/Huxley/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/RepRapPro/Huxley/Configuration_adv.h +++ b/config/examples/RepRapPro/Huxley/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/RepRapWorld/Megatronics/Configuration_adv.h b/config/examples/RepRapWorld/Megatronics/Configuration_adv.h index 9d0e1409a5b..800d8d78ca5 100644 --- a/config/examples/RepRapWorld/Megatronics/Configuration_adv.h +++ b/config/examples/RepRapWorld/Megatronics/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/RepRapWorld/Minitronics20/CNC/Configuration_adv.h b/config/examples/RepRapWorld/Minitronics20/CNC/Configuration_adv.h index bc7a37e6a86..46369091c99 100644 --- a/config/examples/RepRapWorld/Minitronics20/CNC/Configuration_adv.h +++ b/config/examples/RepRapWorld/Minitronics20/CNC/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/RigidBot/Configuration_adv.h b/config/examples/RigidBot/Configuration_adv.h index 3b6406e05af..53424b6703b 100644 --- a/config/examples/RigidBot/Configuration_adv.h +++ b/config/examples/RigidBot/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Robo3D/R1+/Configuration_adv.h b/config/examples/Robo3D/R1+/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Robo3D/R1+/Configuration_adv.h +++ b/config/examples/Robo3D/R1+/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Rolohaun/Rook MK1/Configuration_adv.h b/config/examples/Rolohaun/Rook MK1/Configuration_adv.h index 125c5c1e88b..e65ed3ccf14 100644 --- a/config/examples/Rolohaun/Rook MK1/Configuration_adv.h +++ b/config/examples/Rolohaun/Rook MK1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/SCARA/MP_SCARA/Configuration_adv.h b/config/examples/SCARA/MP_SCARA/Configuration_adv.h index 99c59a05969..22a6181c3c3 100644 --- a/config/examples/SCARA/MP_SCARA/Configuration_adv.h +++ b/config/examples/SCARA/MP_SCARA/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/SCARA/Morgan/Configuration_adv.h b/config/examples/SCARA/Morgan/Configuration_adv.h index f7a35b3f314..aa74d49fbfa 100644 --- a/config/examples/SCARA/Morgan/Configuration_adv.h +++ b/config/examples/SCARA/Morgan/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/STM32/Black_STM32F407VET6/Configuration_adv.h b/config/examples/STM32/Black_STM32F407VET6/Configuration_adv.h index 9411c39fb70..fcdf4461064 100644 --- a/config/examples/STM32/Black_STM32F407VET6/Configuration_adv.h +++ b/config/examples/STM32/Black_STM32F407VET6/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/STM32/STM32F103RE/Configuration_adv.h b/config/examples/STM32/STM32F103RE/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/STM32/STM32F103RE/Configuration_adv.h +++ b/config/examples/STM32/STM32F103RE/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Simax/Mi-M200/Configuration_adv.h b/config/examples/Simax/Mi-M200/Configuration_adv.h index 7d08915fd89..7a1154ae1e1 100644 --- a/config/examples/Simax/Mi-M200/Configuration_adv.h +++ b/config/examples/Simax/Mi-M200/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Simulator/Configuration_adv.h b/config/examples/Simulator/Configuration_adv.h index 6f099f6180b..c1f6af457a9 100644 --- a/config/examples/Simulator/Configuration_adv.h +++ b/config/examples/Simulator/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-01/BigTreeTech SKR E3 Turbo/Configuration_adv.h b/config/examples/Sovol/SV-01/BigTreeTech SKR E3 Turbo/Configuration_adv.h index 22b97ebaf63..509ccefcabc 100644 --- a/config/examples/Sovol/SV-01/BigTreeTech SKR E3 Turbo/Configuration_adv.h +++ b/config/examples/Sovol/SV-01/BigTreeTech SKR E3 Turbo/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 86e4474120b..1f52147a6ae 100644 --- a/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h b/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h index ec2172c8063..06526c41620 100644 --- a/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h +++ b/config/examples/Sovol/SV-01/BigTreeTech SKR Mini E3 3.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-01/CrealityV22/Configuration_adv.h b/config/examples/Sovol/SV-01/CrealityV22/Configuration_adv.h index fa8aba34525..bdccd044d30 100644 --- a/config/examples/Sovol/SV-01/CrealityV22/Configuration_adv.h +++ b/config/examples/Sovol/SV-01/CrealityV22/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-01/CrealityV221/Configuration_adv.h b/config/examples/Sovol/SV-01/CrealityV221/Configuration_adv.h index 423f2c20b33..8c77c636a43 100644 --- a/config/examples/Sovol/SV-01/CrealityV221/Configuration_adv.h +++ b/config/examples/Sovol/SV-01/CrealityV221/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-02/Configuration_adv.h b/config/examples/Sovol/SV-02/Configuration_adv.h index 987f20ec9a4..cdfb9e3b0bd 100644 --- a/config/examples/Sovol/SV-02/Configuration_adv.h +++ b/config/examples/Sovol/SV-02/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-03/Configuration_adv.h b/config/examples/Sovol/SV-03/Configuration_adv.h index b031dff9c4e..6865dc1692c 100644 --- a/config/examples/Sovol/SV-03/Configuration_adv.h +++ b/config/examples/Sovol/SV-03/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-05/Configuration_adv.h b/config/examples/Sovol/SV-05/Configuration_adv.h index 0348c2d385b..bb11d4e5346 100644 --- a/config/examples/Sovol/SV-05/Configuration_adv.h +++ b/config/examples/Sovol/SV-05/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sovol/SV-06/Configuration_adv.h b/config/examples/Sovol/SV-06/Configuration_adv.h index a3268e671fc..ae5bf754067 100644 --- a/config/examples/Sovol/SV-06/Configuration_adv.h +++ b/config/examples/Sovol/SV-06/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sunlu/S8/Configuration_adv.h b/config/examples/Sunlu/S8/Configuration_adv.h index e75b5922c39..49c845b2835 100644 --- a/config/examples/Sunlu/S8/Configuration_adv.h +++ b/config/examples/Sunlu/S8/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Sunlu/T3/Configuration_adv.h b/config/examples/Sunlu/T3/Configuration_adv.h index ca1cf65a680..acbc2e12a25 100644 --- a/config/examples/Sunlu/T3/Configuration_adv.h +++ b/config/examples/Sunlu/T3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/TPARA/AXEL_TPARA/Configuration_adv.h b/config/examples/TPARA/AXEL_TPARA/Configuration_adv.h index 94b6a1aa438..acaa7602122 100644 --- a/config/examples/TPARA/AXEL_TPARA/Configuration_adv.h +++ b/config/examples/TPARA/AXEL_TPARA/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Michelangelo/Configuration_adv.h b/config/examples/Tevo/Michelangelo/Configuration_adv.h index 66535373ade..3397fbb877a 100644 --- a/config/examples/Tevo/Michelangelo/Configuration_adv.h +++ b/config/examples/Tevo/Michelangelo/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Nereus/Configuration_adv.h b/config/examples/Tevo/Nereus/Configuration_adv.h index 7ea2c3b32c5..0dce77084fd 100644 --- a/config/examples/Tevo/Nereus/Configuration_adv.h +++ b/config/examples/Tevo/Nereus/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Tarantula Pro/MKS Gen_L/Configuration_adv.h b/config/examples/Tevo/Tarantula Pro/MKS Gen_L/Configuration_adv.h index b071a22df25..2434ba3c2cb 100644 --- a/config/examples/Tevo/Tarantula Pro/MKS Gen_L/Configuration_adv.h +++ b/config/examples/Tevo/Tarantula Pro/MKS Gen_L/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Tarantula Pro/MKS SGen_L/Configuration_adv.h b/config/examples/Tevo/Tarantula Pro/MKS SGen_L/Configuration_adv.h index 171348f28b6..6f7a668deb7 100644 --- a/config/examples/Tevo/Tarantula Pro/MKS SGen_L/Configuration_adv.h +++ b/config/examples/Tevo/Tarantula Pro/MKS SGen_L/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Tornado/V1 (MKS Base)/Configuration_adv.h b/config/examples/Tevo/Tornado/V1 (MKS Base)/Configuration_adv.h index 1624b0b2c20..17cc52be6b9 100644 --- a/config/examples/Tevo/Tornado/V1 (MKS Base)/Configuration_adv.h +++ b/config/examples/Tevo/Tornado/V1 (MKS Base)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tevo/Tornado/V2 (MKS Gen_L)/Configuration_adv.h b/config/examples/Tevo/Tornado/V2 (MKS Gen_L)/Configuration_adv.h index 1624b0b2c20..17cc52be6b9 100644 --- a/config/examples/Tevo/Tornado/V2 (MKS Gen_L)/Configuration_adv.h +++ b/config/examples/Tevo/Tornado/V2 (MKS Gen_L)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tinkerine/Ditto Pro/RAMPS 1.4/Configuration_adv.h b/config/examples/Tinkerine/Ditto Pro/RAMPS 1.4/Configuration_adv.h index c96019d2b54..08a978e57b6 100644 --- a/config/examples/Tinkerine/Ditto Pro/RAMPS 1.4/Configuration_adv.h +++ b/config/examples/Tinkerine/Ditto Pro/RAMPS 1.4/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/TinyBoy2/Configuration_adv.h b/config/examples/TinyBoy2/Configuration_adv.h index f121c4e6654..8f6cd6af99a 100644 --- a/config/examples/TinyBoy2/Configuration_adv.h +++ b/config/examples/TinyBoy2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/D01/CXY-v6-191017 board/Configuration_adv.h b/config/examples/Tronxy/D01/CXY-v6-191017 board/Configuration_adv.h index 4cff0703ee3..d248f8b18ab 100644 --- a/config/examples/Tronxy/D01/CXY-v6-191017 board/Configuration_adv.h +++ b/config/examples/Tronxy/D01/CXY-v6-191017 board/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X1/Configuration_adv.h b/config/examples/Tronxy/X1/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Tronxy/X1/Configuration_adv.h +++ b/config/examples/Tronxy/X1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X3A/Configuration_adv.h b/config/examples/Tronxy/X3A/Configuration_adv.h index 3826538019c..a8d360d8155 100644 --- a/config/examples/Tronxy/X3A/Configuration_adv.h +++ b/config/examples/Tronxy/X3A/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X5S-2E/Green Board (Chitu V5)/Configuration_adv.h b/config/examples/Tronxy/X5S-2E/Green Board (Chitu V5)/Configuration_adv.h index a0deefa385a..014bdcfef44 100644 --- a/config/examples/Tronxy/X5S-2E/Green Board (Chitu V5)/Configuration_adv.h +++ b/config/examples/Tronxy/X5S-2E/Green Board (Chitu V5)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X5S-2E/Red Board (Tronxy 3.1.0)/Configuration_adv.h b/config/examples/Tronxy/X5S-2E/Red Board (Tronxy 3.1.0)/Configuration_adv.h index 7301e33cee5..a1f0db79ff9 100644 --- a/config/examples/Tronxy/X5S-2E/Red Board (Tronxy 3.1.0)/Configuration_adv.h +++ b/config/examples/Tronxy/X5S-2E/Red Board (Tronxy 3.1.0)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X5S/Configuration_adv.h b/config/examples/Tronxy/X5S/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Tronxy/X5S/Configuration_adv.h +++ b/config/examples/Tronxy/X5S/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X5SA-2E/Configuration_adv.h b/config/examples/Tronxy/X5SA-2E/Configuration_adv.h index e41683e4912..5c9776b3795 100644 --- a/config/examples/Tronxy/X5SA-2E/Configuration_adv.h +++ b/config/examples/Tronxy/X5SA-2E/Configuration_adv.h @@ -4432,93 +4432,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4559,14 +4522,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4575,28 +4533,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4614,12 +4570,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4629,15 +4610,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/X5SA/Configuration_adv.h b/config/examples/Tronxy/X5SA/Configuration_adv.h index ddae586d235..0129cb67a17 100644 --- a/config/examples/Tronxy/X5SA/Configuration_adv.h +++ b/config/examples/Tronxy/X5SA/Configuration_adv.h @@ -4432,93 +4432,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4559,14 +4522,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4575,28 +4533,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4614,12 +4570,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4629,15 +4610,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/XY100/Configuration_adv.h b/config/examples/Tronxy/XY100/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/Tronxy/XY100/Configuration_adv.h +++ b/config/examples/Tronxy/XY100/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Tronxy/XY2-Pro/Configuration_adv.h b/config/examples/Tronxy/XY2-Pro/Configuration_adv.h index 992b5d85a7f..c3fe14c0dde 100644 --- a/config/examples/Tronxy/XY2-Pro/Configuration_adv.h +++ b/config/examples/Tronxy/XY2-Pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Turnigy/Fabrikator/Configuration_adv.h b/config/examples/Turnigy/Fabrikator/Configuration_adv.h index 5f2bb264e36..dbeef36b2a4 100644 --- a/config/examples/Turnigy/Fabrikator/Configuration_adv.h +++ b/config/examples/Turnigy/Fabrikator/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/BlueR Plus/Configuration_adv.h b/config/examples/Two Trees/BlueR Plus/Configuration_adv.h index 1990031a456..73f509a5b26 100644 --- a/config/examples/Two Trees/BlueR Plus/Configuration_adv.h +++ b/config/examples/Two Trees/BlueR Plus/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/BlueR/BlueR V1/Configuration_adv.h b/config/examples/Two Trees/BlueR/BlueR V1/Configuration_adv.h index 5cd15a6aa81..1de8e94b210 100644 --- a/config/examples/Two Trees/BlueR/BlueR V1/Configuration_adv.h +++ b/config/examples/Two Trees/BlueR/BlueR V1/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/BlueR/BlueR V2/Configuration_adv.h b/config/examples/Two Trees/BlueR/BlueR V2/Configuration_adv.h index 5cd15a6aa81..1de8e94b210 100644 --- a/config/examples/Two Trees/BlueR/BlueR V2/Configuration_adv.h +++ b/config/examples/Two Trees/BlueR/BlueR V2/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/BlueR/BlueR V3/Configuration_adv.h b/config/examples/Two Trees/BlueR/BlueR V3/Configuration_adv.h index 5cd15a6aa81..1de8e94b210 100644 --- a/config/examples/Two Trees/BlueR/BlueR V3/Configuration_adv.h +++ b/config/examples/Two Trees/BlueR/BlueR V3/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/SP-5_V3/Configuration_adv.h b/config/examples/Two Trees/SP-5_V3/Configuration_adv.h index 3ebf4d8843a..2a5964f1e5c 100644 --- a/config/examples/Two Trees/SP-5_V3/Configuration_adv.h +++ b/config/examples/Two Trees/SP-5_V3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2.1/Configuration_adv.h b/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2.1/Configuration_adv.h index 0e97d3129bd..2b7d502d542 100644 --- a/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2.1/Configuration_adv.h +++ b/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2.1/Configuration_adv.h @@ -4435,93 +4435,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4562,14 +4525,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4578,28 +4536,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4617,12 +4573,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4632,15 +4613,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2/Configuration_adv.h b/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2/Configuration_adv.h index 63f6717f0d1..c23163f06c4 100644 --- a/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2/Configuration_adv.h +++ b/config/examples/Two Trees/Sapphire Plus/Sapphire Plus V2/Configuration_adv.h @@ -4435,93 +4435,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4562,14 +4525,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4578,28 +4536,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4617,12 +4573,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4632,15 +4613,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Two Trees/Sapphire Pro/Configuration_adv.h b/config/examples/Two Trees/Sapphire Pro/Configuration_adv.h index 829bd309ed6..e61a6a7f24b 100644 --- a/config/examples/Two Trees/Sapphire Pro/Configuration_adv.h +++ b/config/examples/Two Trees/Sapphire Pro/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/UltiMachine/Archim1/Configuration_adv.h b/config/examples/UltiMachine/Archim1/Configuration_adv.h index 81d917206d0..4919cee8aa8 100644 --- a/config/examples/UltiMachine/Archim1/Configuration_adv.h +++ b/config/examples/UltiMachine/Archim1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/UltiMachine/Archim2/Configuration_adv.h b/config/examples/UltiMachine/Archim2/Configuration_adv.h index 252a51220eb..8dfba400498 100644 --- a/config/examples/UltiMachine/Archim2/Configuration_adv.h +++ b/config/examples/UltiMachine/Archim2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ultimaker/Ultimaker 2+/Configuration_adv.h b/config/examples/Ultimaker/Ultimaker 2+/Configuration_adv.h index e32636f4268..7228d92ed8e 100644 --- a/config/examples/Ultimaker/Ultimaker 2+/Configuration_adv.h +++ b/config/examples/Ultimaker/Ultimaker 2+/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ultimaker/Ultimaker 2/Configuration_adv.h b/config/examples/Ultimaker/Ultimaker 2/Configuration_adv.h index e1fac0e2be4..3ae1a26abbf 100644 --- a/config/examples/Ultimaker/Ultimaker 2/Configuration_adv.h +++ b/config/examples/Ultimaker/Ultimaker 2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ultimaker/Ultimaker Original (1.5.7)/Configuration_adv.h b/config/examples/Ultimaker/Ultimaker Original (1.5.7)/Configuration_adv.h index 9a02990f8f5..e770f6fe9c5 100644 --- a/config/examples/Ultimaker/Ultimaker Original (1.5.7)/Configuration_adv.h +++ b/config/examples/Ultimaker/Ultimaker Original (1.5.7)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ultimaker/Ultimaker Original Plus (2.1.1)/Configuration_adv.h b/config/examples/Ultimaker/Ultimaker Original Plus (2.1.1)/Configuration_adv.h index f32d46828a8..23fbcf21a3b 100644 --- a/config/examples/Ultimaker/Ultimaker Original Plus (2.1.1)/Configuration_adv.h +++ b/config/examples/Ultimaker/Ultimaker Original Plus (2.1.1)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Ultimaker/Ultimaker Original Plus DXU/Configuration_adv.h b/config/examples/Ultimaker/Ultimaker Original Plus DXU/Configuration_adv.h index ef3bb7a6f39..b9e09e7dda3 100644 --- a/config/examples/Ultimaker/Ultimaker Original Plus DXU/Configuration_adv.h +++ b/config/examples/Ultimaker/Ultimaker Original Plus DXU/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/VORONDesign/Configuration_adv.h b/config/examples/VORONDesign/Configuration_adv.h index d7fa389dc07..8972a9b883a 100644 --- a/config/examples/VORONDesign/Configuration_adv.h +++ b/config/examples/VORONDesign/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Velleman/K8200 Upgraded/Configuration_adv.h b/config/examples/Velleman/K8200 Upgraded/Configuration_adv.h index 123646747ad..9872138aafa 100644 --- a/config/examples/Velleman/K8200 Upgraded/Configuration_adv.h +++ b/config/examples/Velleman/K8200 Upgraded/Configuration_adv.h @@ -4441,93 +4441,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4568,14 +4531,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4584,28 +4542,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4623,12 +4579,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4638,15 +4619,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Velleman/K8200/Configuration_adv.h b/config/examples/Velleman/K8200/Configuration_adv.h index c9c646a4ed4..32fd8584480 100644 --- a/config/examples/Velleman/K8200/Configuration_adv.h +++ b/config/examples/Velleman/K8200/Configuration_adv.h @@ -4441,93 +4441,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4568,14 +4531,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4584,28 +4542,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4623,12 +4579,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4638,15 +4619,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Velleman/K8400/Dual-head/Configuration_adv.h b/config/examples/Velleman/K8400/Dual-head/Configuration_adv.h index 194f36758be..b80bd32991b 100644 --- a/config/examples/Velleman/K8400/Dual-head/Configuration_adv.h +++ b/config/examples/Velleman/K8400/Dual-head/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Velleman/K8400/Single-head/Configuration_adv.h b/config/examples/Velleman/K8400/Single-head/Configuration_adv.h index 194f36758be..b80bd32991b 100644 --- a/config/examples/Velleman/K8400/Single-head/Configuration_adv.h +++ b/config/examples/Velleman/K8400/Single-head/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Voxelab/Aquila/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h b/config/examples/Voxelab/Aquila/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h index 519337119ba..39063a0fcb7 100644 --- a/config/examples/Voxelab/Aquila/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h +++ b/config/examples/Voxelab/Aquila/BigTreeTech SKR Mini E3 2.0/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/WASP/PowerWASP/Configuration_adv.h b/config/examples/WASP/PowerWASP/Configuration_adv.h index 7afe7e6568e..c1d92627ab2 100644 --- a/config/examples/WASP/PowerWASP/Configuration_adv.h +++ b/config/examples/WASP/PowerWASP/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Wanhao/Duplicator 4S/Configuration_adv.h b/config/examples/Wanhao/Duplicator 4S/Configuration_adv.h index d81f2426a8b..7185a855783 100644 --- a/config/examples/Wanhao/Duplicator 4S/Configuration_adv.h +++ b/config/examples/Wanhao/Duplicator 4S/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Wanhao/Duplicator 6/Configuration_adv.h b/config/examples/Wanhao/Duplicator 6/Configuration_adv.h index fc59f4847b4..1203ab925d6 100644 --- a/config/examples/Wanhao/Duplicator 6/Configuration_adv.h +++ b/config/examples/Wanhao/Duplicator 6/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Wanhao/Duplicator i3 2.1/Configuration_adv.h b/config/examples/Wanhao/Duplicator i3 2.1/Configuration_adv.h index be77a524164..6e56f66e1bd 100644 --- a/config/examples/Wanhao/Duplicator i3 2.1/Configuration_adv.h +++ b/config/examples/Wanhao/Duplicator i3 2.1/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Wanhao/Duplicator i3 Mini/Configuration_adv.h b/config/examples/Wanhao/Duplicator i3 Mini/Configuration_adv.h index 1b7c7056f6e..40d6c531ab8 100644 --- a/config/examples/Wanhao/Duplicator i3 Mini/Configuration_adv.h +++ b/config/examples/Wanhao/Duplicator i3 Mini/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Wanhao/Duplicator i3 Plus/Configuration_adv.h b/config/examples/Wanhao/Duplicator i3 Plus/Configuration_adv.h index 8739a2c8901..7e19ec26501 100644 --- a/config/examples/Wanhao/Duplicator i3 Plus/Configuration_adv.h +++ b/config/examples/Wanhao/Duplicator i3 Plus/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Weedo/Tina2/V2/Configuration_adv.h b/config/examples/Weedo/Tina2/V2/Configuration_adv.h index d50a58dd667..f6e74528c0c 100644 --- a/config/examples/Weedo/Tina2/V2/Configuration_adv.h +++ b/config/examples/Weedo/Tina2/V2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Weedo/Tina2/V3/Configuration_adv.h b/config/examples/Weedo/Tina2/V3/Configuration_adv.h index d50a58dd667..f6e74528c0c 100644 --- a/config/examples/Weedo/Tina2/V3/Configuration_adv.h +++ b/config/examples/Weedo/Tina2/V3/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Weistek/wt150/Configuration_adv.h b/config/examples/Weistek/wt150/Configuration_adv.h index afae1e1a1cc..008d6c04f54 100644 --- a/config/examples/Weistek/wt150/Configuration_adv.h +++ b/config/examples/Weistek/wt150/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Zonestar/P802M/Configuration_adv.h b/config/examples/Zonestar/P802M/Configuration_adv.h index 6b8467df84b..99b5b8ca840 100644 --- a/config/examples/Zonestar/P802M/Configuration_adv.h +++ b/config/examples/Zonestar/P802M/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (A4988)/Configuration_adv.h b/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (A4988)/Configuration_adv.h index bb0159c9dd5..6faaf33614f 100644 --- a/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (A4988)/Configuration_adv.h +++ b/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (A4988)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (TMC2209)/Configuration_adv.h b/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (TMC2209)/Configuration_adv.h index 79354909927..5880ce6e8cb 100644 --- a/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (TMC2209)/Configuration_adv.h +++ b/config/examples/Zonestar/P802QR2/BigTreeTech SKR 1.4 Turbo (TMC2209)/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Anycubic/Kossel Linear Plus/Configuration_adv.h b/config/examples/delta/Anycubic/Kossel Linear Plus/Configuration_adv.h index 96db545e45a..a8b90d84336 100644 --- a/config/examples/delta/Anycubic/Kossel Linear Plus/Configuration_adv.h +++ b/config/examples/delta/Anycubic/Kossel Linear Plus/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Anycubic/Kossel/Configuration_adv.h b/config/examples/delta/Anycubic/Kossel/Configuration_adv.h index 4e74b7e1e34..3220a76b383 100644 --- a/config/examples/delta/Anycubic/Kossel/Configuration_adv.h +++ b/config/examples/delta/Anycubic/Kossel/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Anycubic/Predator/Configuration_adv.h b/config/examples/delta/Anycubic/Predator/Configuration_adv.h index b262099a5f5..49cfc9ba312 100644 --- a/config/examples/delta/Anycubic/Predator/Configuration_adv.h +++ b/config/examples/delta/Anycubic/Predator/Configuration_adv.h @@ -4431,93 +4431,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4558,14 +4521,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4574,28 +4532,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4613,12 +4569,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4628,15 +4609,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Dreammaker/Overlord/Configuration_adv.h b/config/examples/delta/Dreammaker/Overlord/Configuration_adv.h index ae662d2dc55..b1e79e120f0 100644 --- a/config/examples/delta/Dreammaker/Overlord/Configuration_adv.h +++ b/config/examples/delta/Dreammaker/Overlord/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Dreammaker/Overlord_Pro/Configuration_adv.h b/config/examples/delta/Dreammaker/Overlord_Pro/Configuration_adv.h index ae662d2dc55..b1e79e120f0 100644 --- a/config/examples/delta/Dreammaker/Overlord_Pro/Configuration_adv.h +++ b/config/examples/delta/Dreammaker/Overlord_Pro/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/Q5-nano_v1/Configuration_adv.h b/config/examples/delta/FLSUN/Q5-nano_v1/Configuration_adv.h index 8544510c03a..9267f6b46f3 100644 --- a/config/examples/delta/FLSUN/Q5-nano_v1/Configuration_adv.h +++ b/config/examples/delta/FLSUN/Q5-nano_v1/Configuration_adv.h @@ -4427,93 +4427,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4554,14 +4517,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4570,28 +4528,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4609,12 +4565,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4624,15 +4605,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/Q5-nano_v2/Configuration_adv.h b/config/examples/delta/FLSUN/Q5-nano_v2/Configuration_adv.h index ff21b734f50..8bc6b4ea22c 100644 --- a/config/examples/delta/FLSUN/Q5-nano_v2/Configuration_adv.h +++ b/config/examples/delta/FLSUN/Q5-nano_v2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/QQ-S/Configuration_adv.h b/config/examples/delta/FLSUN/QQ-S/Configuration_adv.h index 3ea75014734..a5ca0f9232d 100644 --- a/config/examples/delta/FLSUN/QQ-S/Configuration_adv.h +++ b/config/examples/delta/FLSUN/QQ-S/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/QQS-Pro/Configuration_adv.h b/config/examples/delta/FLSUN/QQS-Pro/Configuration_adv.h index 2d3447a6e4f..033e10db3e3 100644 --- a/config/examples/delta/FLSUN/QQS-Pro/Configuration_adv.h +++ b/config/examples/delta/FLSUN/QQS-Pro/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h b/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h index a6f1fa963ee..694e22e8357 100644 --- a/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h +++ b/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/kossel/Configuration_adv.h b/config/examples/delta/FLSUN/kossel/Configuration_adv.h index a6f1fa963ee..694e22e8357 100644 --- a/config/examples/delta/FLSUN/kossel/Configuration_adv.h +++ b/config/examples/delta/FLSUN/kossel/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h b/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h index 4fa865308da..5418be8c46d 100644 --- a/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h +++ b/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Geeetech/G2/Configuration_adv.h b/config/examples/delta/Geeetech/G2/Configuration_adv.h index 298e39e29bf..fe722d6662e 100644 --- a/config/examples/delta/Geeetech/G2/Configuration_adv.h +++ b/config/examples/delta/Geeetech/G2/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Geeetech/G2Pro/Configuration_adv.h b/config/examples/delta/Geeetech/G2Pro/Configuration_adv.h index 298e39e29bf..fe722d6662e 100644 --- a/config/examples/delta/Geeetech/G2Pro/Configuration_adv.h +++ b/config/examples/delta/Geeetech/G2Pro/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Geeetech/G2S/Configuration_adv.h b/config/examples/delta/Geeetech/G2S/Configuration_adv.h index 298e39e29bf..fe722d6662e 100644 --- a/config/examples/delta/Geeetech/G2S/Configuration_adv.h +++ b/config/examples/delta/Geeetech/G2S/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Geeetech/G2SPro/Configuration_adv.h b/config/examples/delta/Geeetech/G2SPro/Configuration_adv.h index 298e39e29bf..fe722d6662e 100644 --- a/config/examples/delta/Geeetech/G2SPro/Configuration_adv.h +++ b/config/examples/delta/Geeetech/G2SPro/Configuration_adv.h @@ -4426,93 +4426,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4553,14 +4516,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4569,28 +4527,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4608,12 +4564,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4623,15 +4604,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Geeetech/Rostock 301/Configuration_adv.h b/config/examples/delta/Geeetech/Rostock 301/Configuration_adv.h index 12f4effae45..bdd65118d42 100644 --- a/config/examples/delta/Geeetech/Rostock 301/Configuration_adv.h +++ b/config/examples/delta/Geeetech/Rostock 301/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Hatchbox_Alpha/Configuration_adv.h b/config/examples/delta/Hatchbox_Alpha/Configuration_adv.h index 680a53f66df..4722dc88b5c 100644 --- a/config/examples/delta/Hatchbox_Alpha/Configuration_adv.h +++ b/config/examples/delta/Hatchbox_Alpha/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/MKS/SBASE/Configuration_adv.h b/config/examples/delta/MKS/SBASE/Configuration_adv.h index 10284cda7e9..109c17c844c 100644 --- a/config/examples/delta/MKS/SBASE/Configuration_adv.h +++ b/config/examples/delta/MKS/SBASE/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Malyan M300/Configuration_adv.h b/config/examples/delta/Malyan M300/Configuration_adv.h index aa3fe6e1aa2..5135f3ad088 100644 --- a/config/examples/delta/Malyan M300/Configuration_adv.h +++ b/config/examples/delta/Malyan M300/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Tevo Little Monster/Configuration_adv.h b/config/examples/delta/Tevo Little Monster/Configuration_adv.h index 3cbabebee83..e789b2b2ff0 100644 --- a/config/examples/delta/Tevo Little Monster/Configuration_adv.h +++ b/config/examples/delta/Tevo Little Monster/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/Velleman/K8800/Configuration_adv.h b/config/examples/delta/Velleman/K8800/Configuration_adv.h index f4b316ea6d3..55d539a45d3 100644 --- a/config/examples/delta/Velleman/K8800/Configuration_adv.h +++ b/config/examples/delta/Velleman/K8800/Configuration_adv.h @@ -4433,93 +4433,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4560,14 +4523,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4576,28 +4534,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4615,12 +4571,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4630,15 +4611,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/generic/Configuration_adv.h b/config/examples/delta/generic/Configuration_adv.h index 4fa865308da..5418be8c46d 100644 --- a/config/examples/delta/generic/Configuration_adv.h +++ b/config/examples/delta/generic/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/kossel_clear/Configuration_adv.h b/config/examples/delta/kossel_clear/Configuration_adv.h index fa655b6fd51..4b082d3a94e 100644 --- a/config/examples/delta/kossel_clear/Configuration_adv.h +++ b/config/examples/delta/kossel_clear/Configuration_adv.h @@ -4430,93 +4430,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4557,14 +4520,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4573,28 +4531,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4612,12 +4568,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4627,15 +4608,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/kossel_mini/Configuration_adv.h b/config/examples/delta/kossel_mini/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/delta/kossel_mini/Configuration_adv.h +++ b/config/examples/delta/kossel_mini/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/kossel_pro/Configuration_adv.h b/config/examples/delta/kossel_pro/Configuration_adv.h index 9ca8a1c4e72..78a19aaa21f 100644 --- a/config/examples/delta/kossel_pro/Configuration_adv.h +++ b/config/examples/delta/kossel_pro/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/delta/kossel_xl/Configuration_adv.h b/config/examples/delta/kossel_xl/Configuration_adv.h index dfa57a34a00..daa2273b241 100644 --- a/config/examples/delta/kossel_xl/Configuration_adv.h +++ b/config/examples/delta/kossel_xl/Configuration_adv.h @@ -4429,93 +4429,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4556,14 +4519,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4572,28 +4530,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4611,12 +4567,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4626,15 +4607,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/gCreate/gMax1.5+/Configuration_adv.h b/config/examples/gCreate/gMax1.5+/Configuration_adv.h index a2002f7eecb..416ee24728d 100644 --- a/config/examples/gCreate/gMax1.5+/Configuration_adv.h +++ b/config/examples/gCreate/gMax1.5+/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/linear_axes/Octopus 8 LINEAR_AXES/Configuration_adv.h b/config/examples/linear_axes/Octopus 8 LINEAR_AXES/Configuration_adv.h index 050af9b50f2..025cbff6039 100644 --- a/config/examples/linear_axes/Octopus 8 LINEAR_AXES/Configuration_adv.h +++ b/config/examples/linear_axes/Octopus 8 LINEAR_AXES/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/linear_axes/RAMPS 5 LINEAR_AXES/Configuration_adv.h b/config/examples/linear_axes/RAMPS 5 LINEAR_AXES/Configuration_adv.h index bdb10e9755e..ab2a23e994f 100644 --- a/config/examples/linear_axes/RAMPS 5 LINEAR_AXES/Configuration_adv.h +++ b/config/examples/linear_axes/RAMPS 5 LINEAR_AXES/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/makibox/Configuration_adv.h b/config/examples/makibox/Configuration_adv.h index 4a7ee78ab3f..05cbb8ab9b3 100644 --- a/config/examples/makibox/Configuration_adv.h +++ b/config/examples/makibox/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /** diff --git a/config/examples/tvrrug/Round2/Configuration_adv.h b/config/examples/tvrrug/Round2/Configuration_adv.h index a44cd8ea685..a72e3c50124 100644 --- a/config/examples/tvrrug/Round2/Configuration_adv.h +++ b/config/examples/tvrrug/Round2/Configuration_adv.h @@ -4428,93 +4428,56 @@ //#define E_MUX0_PIN 40 // Always Required //#define E_MUX1_PIN 42 // Needed for 3 to 8 inputs //#define E_MUX2_PIN 44 // Needed for 5 to 8 inputs + #elif HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 // Common settings for MMU2/MMU2S/MMU3 // Serial port used for communication with MMU2/MMU2S/MMU3. - #define MMU2_SERIAL_PORT 2 + #define MMU_SERIAL_PORT 2 #define MMU_BAUD 115200 - // Use hardware reset for MMU if a pin is defined for it - //#define MMU2_RST_PIN 23 + //#define MMU_RST_PIN 23 // Define this pin to use Hardware Reset for MMU2/MMU2S/MMU3 + + //#define MMU_MENUS // Add an LCD menu for MMU2/MMU2S/MMU3 + + //#define MMU_DEBUG // Write debug info to serial output + // Options pertaining to MMU2 and MMU2S #if HAS_PRUSA_MMU2 // Enable if the MMU2 has 12V stepper motors (MMU2 Firmware 1.0.2 and up) //#define MMU2_MODE_12V + // Settings for filament load / unload from the LCD menu. + // This is for Průša MK3-style extruders. Customize for your hardware. + #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // G-code to execute when MMU2 F.I.N.D.A. probe detects filament runout #define MMU2_FILAMENT_RUNOUT_SCRIPT "M600" - #endif - // Add an LCD menu for MMU2/MMU2S/MMU3 - //#define MMU_MENUS - - // Settings for filament load / unload from the LCD menu. - // This is for Průša MK3-style extruders. Customize for your hardware. - #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0 + // MMU2 sequences use mm/min. Not compatible with MMU3, which use mm/sec. + #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ + { 4.4, 871 }, \ + { 10.0, 1393 }, \ + { 4.4, 871 }, \ + { 10.0, 198 } + + #define MMU2_RAMMING_SEQUENCE \ + { 1.0, 1000 }, \ + { 1.0, 1500 }, \ + { 2.0, 2000 }, \ + { 1.5, 3000 }, \ + { 2.5, 4000 }, \ + { -15.0, 5000 }, \ + { -14.0, 1200 }, \ + { -6.0, 600 }, \ + { 10.0, 700 }, \ + { -10.0, 400 }, \ + { -50.0, 2000 } + + #endif // HAS_PRUSA_MMU2 /** - * ------------ - * MMU2 / MMU2S - * ------------ - * MMU2 sequences use mm/min. Not compatible with MMU3 (see below). - * #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - * { 4.4, 871 }, \ - * { 10.0, 1393 }, \ - * { 4.4, 871 }, \ - * { 10.0, 198 } - */ - - /* #define MMU2_RAMMING_SEQUENCE \ - * { 1.0, 1000 }, \ - * { 1.0, 1500 }, \ - * { 2.0, 2000 }, \ - * { 1.5, 3000 }, \ - * { 2.5, 4000 }, \ - * { -15.0, 5000 }, \ - * { -14.0, 1200 }, \ - * { -6.0, 600 }, \ - * { 10.0, 700 }, \ - * { -10.0, 400 }, \ - * { -50.0, 2000 } - */ - - /** - * ---- - * MMU3 - * ---- - * These values are compatible with MMU3 as they are defined in mm/s - */ - - #define MMU2_EXTRUDER_PTFE_LENGTH 42.3 // (mm) - #define MMU2_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) - - #define MMU2_LOAD_TO_NOZZLE_SEQUENCE \ - { MMU2_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ - { MMU2_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } // ( 3.3 mm/s) Slow load after heatbreak - - #define MMU2_RAMMING_SEQUENCE \ - { 0.2816, MMM_TO_MMS(1339.0) }, \ - { 0.3051, MMM_TO_MMS(1451.0) }, \ - { 0.3453, MMM_TO_MMS(1642.0) }, \ - { 0.3990, MMM_TO_MMS(1897.0) }, \ - { 0.4761, MMM_TO_MMS(2264.0) }, \ - { 0.5767, MMM_TO_MMS(2742.0) }, \ - { 0.5691, MMM_TO_MMS(3220.0) }, \ - { 0.1081, MMM_TO_MMS(3220.0) }, \ - { 0.7644, MMM_TO_MMS(3635.0) }, \ - { 0.8248, MMM_TO_MMS(3921.0) }, \ - { 0.8483, MMM_TO_MMS(4033.0) }, \ - { -15.0, MMM_TO_MMS(6000.0) }, \ - { -24.5, MMM_TO_MMS(1200.0) }, \ - { -7.0, MMM_TO_MMS( 600.0) }, \ - { -3.5, MMM_TO_MMS( 360.0) }, \ - { 20.0, MMM_TO_MMS( 454.0) }, \ - { -20.0, MMM_TO_MMS( 303.0) }, \ - { -35.0, MMM_TO_MMS(2000.0) } - - /** - * Using a sensor like the MMU2S - * This mode requires a MK3S extruder with a sensor at the extruder idler, like the MMU2S. + * Options pertaining to MMU2S devices + * Requires the MK3S extruder with a sensor at the extruder idler, like the MMU2S. * See https://help.prusa3d.com/guide/3b-mk3s-mk2-5s-extruder-upgrade_41560#42048, step 11 */ #if HAS_PRUSA_MMU2S @@ -4555,14 +4518,9 @@ // MMU3 settings - #define MMU2_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) + #define MMU3_HAS_CUTTER // Enable cutter related functionality - // Nominal distance from the extruder gear to the nozzle tip is 87mm - // However, some slipping may occur and we need separate distances for - // LoadToNozzle and ToolChange. - // - +5mm seemed good for LoadToNozzle, - // - but too much (made blobs) for a ToolChange - #define MMU2_LOAD_TO_NOZZLE_LENGTH 87.0 + 5.0 + #define MMU3_MAX_RETRIES 3 // Number of retries (total time = timeout*retries) // As discussed with our PrusaSlicer profile specialist // - ToolChange shall not try to push filament into the very tip of the nozzle @@ -4571,28 +4529,26 @@ // 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) // However - in the G-code we can get a request to set the extra load distance at runtime to something else (M708 A0xb Xsomething). // The printer intercepts such a call and sets its extra load distance to match the new value as well. - #define MMU2_FILAMENT_SENSOR_POSITION 0 // (mm) - #define MMU2_LOAD_DISTANCE_PAST_GEARS 5 // (mm) - #define MMU2_TOOL_CHANGE_LOAD_LENGTH MMU2_FILAMENT_SENSOR_POSITION + MMU2_LOAD_DISTANCE_PAST_GEARS // (mm) + #define MMU3_FILAMENT_SENSOR_E_POSITION 0 // (mm) + #define _MMU3_LOAD_DISTANCE_PAST_GEARS 5 // (mm) + #define MMU3_TOOL_CHANGE_LOAD_LENGTH (MMU3_FILAMENT_SENSOR_E_POSITION + _MMU3_LOAD_DISTANCE_PAST_GEARS) // (mm) - #define MMU2_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_UNLOAD_TO_FINDA_FEED_RATE 120.0 // (mm/s) + #define MMU3_LOAD_TO_NOZZLE_FEED_RATE 20.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) - #define MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle + #define MMU3_VERIFY_LOAD_TO_NOZZLE_FEED_RATE 50.0 // (mm/s) + #define _MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK -5.0 // (mm) Amount to adjust the length for verifying load-to-nozzle // The first thing the MMU does is initialize its axis. // Meanwhile the E-motor will unload 20mm of filament in about 1 second. - #define MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) - #define MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) + #define MMU3_RETRY_UNLOAD_TO_FINDA_LENGTH 80.0 // (mm) + #define MMU3_RETRY_UNLOAD_TO_FINDA_FEED_RATE 80.0 // (mm/s) // After loading a new filament, the printer will extrude this length of filament // then retract to the original position. This is used to check if the filament sensor // reading flickers or filament is jammed. - #define MMU2_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (MMU2_EXTRUDER_PTFE_LENGTH + MMU2_EXTRUDER_HEATBREAK_LENGTH + MMU2_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU2_FILAMENT_SENSOR_POSITION) // (mm) - - #define MMU_HAS_CUTTER // Enable cutter related functionalities - //#define MMU_FORCE_STEALTH_MODE // Force stealth mode and disable menu item + #define _MMU_EXTRUDER_PTFE_LENGTH 42.3 // (mm) + #define _MMU_EXTRUDER_HEATBREAK_LENGTH 17.7 // (mm) + #define MMU3_CHECK_FILAMENT_PRESENCE_EXTRUSION_LENGTH (_MMU_EXTRUDER_PTFE_LENGTH + _MMU_EXTRUDER_HEATBREAK_LENGTH + MMU3_VERIFY_LOAD_TO_NOZZLE_TWEAK + MMU3_FILAMENT_SENSOR_E_POSITION) // (mm) /** * SpoolJoin Consumes All Filament -- EXPERIMENTAL @@ -4610,12 +4566,37 @@ * sensor is triggered through the gears) and the end of the PTFE tube and * can cause filament load issues. */ - //#define MMU_SPOOL_JOIN_CONSUMES_ALL_FILAMENT - - #else + //#define MMU3_SPOOL_JOIN_CONSUMES_ALL_FILAMENT + + // MMU3 sequences use mm/sec. Not compatible with MMU2 which use mm/min. + #define MMU3_LOAD_TO_NOZZLE_SEQUENCE \ + { _MMU_EXTRUDER_PTFE_LENGTH, MMM_TO_MMS(810) }, /* (13.5 mm/s) Fast load ahead of heatbreak */ \ + { _MMU_EXTRUDER_HEATBREAK_LENGTH, MMM_TO_MMS(198) } /* ( 3.3 mm/s) Slow load after heatbreak */ + + #define MMU3_RAMMING_SEQUENCE \ + { 0.2816, MMM_TO_MMS(1339.0) }, \ + { 0.3051, MMM_TO_MMS(1451.0) }, \ + { 0.3453, MMM_TO_MMS(1642.0) }, \ + { 0.3990, MMM_TO_MMS(1897.0) }, \ + { 0.4761, MMM_TO_MMS(2264.0) }, \ + { 0.5767, MMM_TO_MMS(2742.0) }, \ + { 0.5691, MMM_TO_MMS(3220.0) }, \ + { 0.1081, MMM_TO_MMS(3220.0) }, \ + { 0.7644, MMM_TO_MMS(3635.0) }, \ + { 0.8248, MMM_TO_MMS(3921.0) }, \ + { 0.8483, MMM_TO_MMS(4033.0) }, \ + { -15.0, MMM_TO_MMS(6000.0) }, \ + { -24.5, MMM_TO_MMS(1200.0) }, \ + { -7.0, MMM_TO_MMS( 600.0) }, \ + { -3.5, MMM_TO_MMS( 360.0) }, \ + { 20.0, MMM_TO_MMS( 454.0) }, \ + { -20.0, MMM_TO_MMS( 303.0) }, \ + { -35.0, MMM_TO_MMS(2000.0) } + + #else // MMU2 (not MMU2S) /** - * MMU1 Extruder Sensor + * MMU2 Extruder Sensor * * Support for a Průša (or other) IR Sensor to detect filament near the extruder * and make loading more reliable. Suitable for an extruder equipped with a filament @@ -4625,15 +4606,13 @@ * move up to the gears. If no filament is detected, the MMU2 can make some more attempts. * If all attempts fail, a filament runout will be triggered. */ - //#define MMU_EXTRUDER_SENSOR - #if ENABLED(MMU_EXTRUDER_SENSOR) - #define MMU_LOADING_ATTEMPTS_NR 5 // max. number of attempts to load filament if first load fail + //#define MMU2_EXTRUDER_SENSOR + #if ENABLED(MMU2_EXTRUDER_SENSOR) + #define MMU2_LOADING_ATTEMPTS_NR 5 // Number of times to try loading filament before failure #endif #endif - //#define MMU2_DEBUG // Write debug info to serial output - #endif // HAS_PRUSA_MMU2 || HAS_PRUSA_MMU3 /**