mmu2.h

Go to the documentation of this file.

#pragma once
 
#include "mmu2_state.h"
#include "mmu2_marlin.h"
 
#ifdef __AVR__
    #include "mmu2_protocol_logic.h"
typedef float feedRate_t;
 
#else
    #include "protocol_logic.h"
    #include <atomic>
#endif
 
struct E_Step;
 
namespace MMU2 {
 
// general MMU setup for MK3
enum : uint8_t {
    FILAMENT_UNKNOWN = 0xffU
};
 
struct Version {
    uint8_t major, minor, build;
};
 
class MMU2 {
public:
    MMU2();
 
    void Start();
 
    void Stop();
 
    void Status();
 
    inline xState State() const { return state; }
 
    inline bool Enabled() const { return State() == xState::Active; }
 
    enum ResetForm : uint8_t {
        Software = 0,     
        ResetPin = 1,     
        CutThePower = 2,  
        EraseEEPROM = 42, 
    };
 
    enum SavedState : uint8_t {
        None = 0,         // No state saved.
        ParkExtruder = 1, // The extruder was parked.
        Cooldown = 2,     // The extruder was allowed to cool.
        CooldownPending = 4,
    };
 
    enum ErrorSource : uint8_t {
        ErrorSourcePrinter = 0,
        ErrorSourceMMU = 1,
        ErrorSourceNone = 0xFF,
    };
 
    void Tune();
 
    void Reset(ResetForm level);
 
    void PowerOff();
 
    void PowerOn();
 
    bool ReadRegister(uint8_t address);
 
    bool WriteRegister(uint8_t address, uint16_t data);
 
    void mmu_loop();
 
    bool tool_change(uint8_t slot);
 
    bool tool_change(char code, uint8_t slot);
 
    bool unload();
 
    bool load_filament(uint8_t slot);
 
    bool load_filament_to_nozzle(uint8_t slot);
 
    bool eject_filament(uint8_t slot, bool enableFullScreenMsg = true);
 
    bool cut_filament(uint8_t slot, bool enableFullScreenMsg = true);
 
    void get_statistics();
 
    bool loading_test(uint8_t slot);
 
    uint8_t get_current_tool() const;
 
    uint8_t get_tool_change_tool() const;
 
    bool set_filament_type(uint8_t slot, uint8_t type);
 
    void Button(uint8_t index);
 
    void Home(uint8_t mode);
 
    inline bool FindaDetectsFilament() const { return logic.FindaPressed(); }
 
    inline uint16_t TotalFailStatistics() const { return logic.FailStatistics(); }
 
    inline ErrorCode MMUCurrentErrorCode() const { return logic.Error(); }
 
    inline uint8_t GetCommandInProgress() const { return logic.CommandInProgress(); }
 
    inline ErrorSource MMULastErrorSource() const { return lastErrorSource; }
 
    inline ErrorCode GetLastErrorCode() const { return lastErrorCode; }
 
    Version GetMMUFWVersion() const {
        if (State() == xState::Active) {
            return { logic.MmuFwVersionMajor(), logic.MmuFwVersionMinor(), logic.MmuFwVersionRevision() };
        } else {
            return { 0, 0, 0 };
        }
    }
 
    inline bool MMU_PRINT_SAVED() const { return mmu_print_saved != SavedState::None; }
 
    bool RetryIfPossible(ErrorCode ec);
 
    inline uint16_t ToolChangeCounter() const { return toolchange_counter; };
 
    inline void ClearToolChangeCounter() { toolchange_counter = 0; };
 
    inline uint16_t TMCFailures() const { return tmcFailures; }
    inline void IncrementTMCFailures() { ++tmcFailures; }
    inline void ClearTMCFailures() { tmcFailures = 0; }
 
    inline uint16_t GetLastReadRegisterValue() const {
        return lastReadRegisterValue;
    };
    inline void InvokeErrorScreen(ErrorCode ec) {
        // The printer may not raise an error when the MMU is busy
        if (!logic.CommandInProgress()                // MMU must not be busy
            && MMUCurrentErrorCode() == ErrorCode::OK // The protocol must not be in error state
            && lastErrorCode != ec)                   // The error code is not a duplicate
        {
            ReportError(ec, ErrorSource::ErrorSourcePrinter);
        }
    }
 
    void ClearPrinterError() {
        logic.ClearPrinterError();
        lastErrorCode = ErrorCode::OK;
        lastErrorSource = ErrorSource::ErrorSourceNone;
    }
 
    inline void SetPrinterButtonOperation(Buttons btn) {
        printerButtonOperation = btn;
    }
 
    inline Buttons GetPrinterButtonOperation() {
        return printerButtonOperation;
    }
 
    inline void ClearPrinterButtonOperation() {
        printerButtonOperation = Buttons::NoButton;
    }
 
#ifndef UNITTEST
private:
#endif
    void ResetX0();
 
    void ResetX42();
 
    void TriggerResetPin();
 
    void PowerCycle();
 
    void StopKeepPowered();
 
    [[nodiscard]] bool manage_response(const bool move_axes, const bool turn_off_nozzle);
 
    void mmu_loop_inner(bool reportErrors);
 
    StepStatus LogicStep(bool reportErrors);
 
    void filament_ramming();
    void execute_extruder_sequence(const E_Step *sequence, uint8_t steps);
    void execute_load_to_nozzle_sequence();
 
    void ReportError(ErrorCode ec, ErrorSource res);
 
    void ReportProgress(ProgressCode pc);
 
    void OnMMUProgressMsg(ProgressCode pc);
    void OnMMUProgressMsgChanged(ProgressCode pc);
    void OnMMUProgressMsgSame(ProgressCode pc);
 
    void SaveHotendTemp(bool turn_off_nozzle);
 
    void SaveAndPark(bool move_axes);
 
    void ResumeHotendTemp();
 
    void ResumeUnpark();
 
    void CheckUserInput();
 
    void CheckFINDARunout();
 
    bool WaitForMMUReady();
 
    bool VerifyFilamentEnteredPTFE();
 
    void ToolChangeCommon(uint8_t slot);
    bool ToolChangeCommonOnce(uint8_t slot);
 
    void HelpUnloadToFinda();
    void UnloadInner();
    void CutFilamentInner(uint8_t slot);
 
    void SetCurrentTool(uint8_t ex);
 
    ProtocolLogic logic;          
    uint8_t extruder;             
    uint8_t tool_change_extruder; 
 
    pos3d resume_position;
    int16_t resume_hotend_temp;
 
    ProgressCode lastProgressCode = ProgressCode::OK;
    ErrorCode lastErrorCode = ErrorCode::MMU_NOT_RESPONDING;
    ErrorSource lastErrorSource = ErrorSource::ErrorSourceNone;
    Buttons lastButton = Buttons::NoButton;
    uint16_t lastReadRegisterValue = 0;
    Buttons printerButtonOperation = Buttons::NoButton;
 
    StepStatus logicStepLastStatus;
 
    enum xState state;
 
    uint8_t mmu_print_saved;
    bool loadFilamentStarted;
    bool unloadFilamentStarted;
 
    uint16_t toolchange_counter;
    uint16_t tmcFailures;
};
 
extern MMU2 mmu2;
 
} // namespace MMU2