mmu2_protocol_logic.h

#pragma once
#include <stdint.h>
#include <avr/pgmspace.h>
 
#ifdef __AVR__
    #include "mmu2/error_codes.h"
    #include "mmu2/progress_codes.h"
    #include "mmu2/buttons.h"
    #include "mmu2/registers.h"
    #include "mmu2_protocol.h"
 
// #include <array> std array is not available on AVR ... we need to "fake" it
namespace std {
template <typename T, uint8_t N>
class array {
    T data[N];
 
public:
    array() = default;
    inline constexpr T *begin() const { return data; }
    inline constexpr T *end() const { return data + N; }
    static constexpr uint8_t size() { return N; }
    inline T &operator[](uint8_t i) {
        return data[i];
    }
};
} // namespace std
#else
 
    #include <array>
    #include "../../../../../../Prusa-Firmware-MMU/src/logic/error_codes.h"
    #include "../../../../../../Prusa-Firmware-MMU/src/logic/progress_codes.h"
 
    // prevent ARM HAL macros from breaking our code
    #undef CRC
    #include "../../../../../../Prusa-Firmware-MMU/src/modules/protocol.h"
    #include "buttons.h"
    #include "registers.h"
#endif
 
#include "mmu2_serial.h"
 
namespace MMU2 {
 
static constexpr uint8_t MAX_RETRIES = 3U;
 
using namespace modules::protocol;
 
class ProtocolLogic;
 
enum StepStatus : uint_fast8_t {
    Processing = 0,
    MessageReady,         
    Finished,             
    Interrupted,          
    CommunicationTimeout, 
    ProtocolError,        
    CommandRejected,      
    CommandError,         
    VersionMismatch,      
    PrinterError,         
    CommunicationRecovered,
    ButtonPushed,         
};
 
inline constexpr uint32_t linkLayerTimeout = 2000;                 
inline constexpr uint32_t dataLayerTimeout = linkLayerTimeout * 3; 
inline constexpr uint32_t heartBeatPeriod = linkLayerTimeout / 2;  
 
static_assert(heartBeatPeriod < linkLayerTimeout && linkLayerTimeout < dataLayerTimeout, "Incorrect ordering of timeouts");
 
class DropOutFilter {
public:
    static constexpr uint8_t maxOccurrences = 10; // ideally set this to >8 seconds -> 12x heartBeatPeriod
    static_assert(maxOccurrences > 1, "we should really silently ignore at least 1 comm drop out if recovered immediately afterwards");
    DropOutFilter() = default;
 
    bool Record(StepStatus ss);
 
    inline StepStatus InitialCause() const { return cause; }
 
    inline void Reset() { occurrences = maxOccurrences; }
 
private:
    StepStatus cause;
    uint8_t occurrences = maxOccurrences;
};
 
class ProtocolLogic {
public:
    ProtocolLogic(MMU2Serial *uart, uint8_t extraLoadDistance, uint8_t pulleySlowFeedrate);
 
    void Start();
 
    void Stop();
 
    // Issue commands to the MMU
    void ToolChange(uint8_t slot);
    void Statistics();
    void UnloadFilament();
    void LoadFilament(uint8_t slot);
    void EjectFilament(uint8_t slot);
    void CutFilament(uint8_t slot);
    void ResetMMU(uint8_t mode = 0);
    void Button(uint8_t index);
    void Home(uint8_t mode);
    void ReadRegister(uint8_t address);
    void WriteRegister(uint8_t address, uint16_t data);
 
    inline void PlanExtraLoadDistance(uint8_t eld_mm) {
        initRegs8[0] = eld_mm;
    }
    inline uint8_t ExtraLoadDistance() const {
        return initRegs8[0];
    }
 
    inline void PlanPulleySlowFeedRate(uint8_t psfr) {
        initRegs8[1] = psfr;
    }
    inline uint8_t PulleySlowFeedRate() const {
        return initRegs8[1]; // even though MMU register 0x14 is 16bit, reasonable speeds are way below 255mm/s - saving space ;)
    }
 
    StepStatus Step();
 
    ErrorCode Error() const { return errorCode; }
 
    ProgressCode Progress() const { return progressCode; }
 
    Buttons Button() const { return buttonCode; }
 
    uint8_t CommandInProgress() const;
 
    inline bool Running() const {
        return state == State::Running;
    }
 
    inline bool FindaPressed() const {
        return regs8[0];
    }
 
    inline uint16_t FailStatistics() const {
        return regs16[0];
    }
 
    inline uint8_t MmuFwVersionMajor() const {
        return mmuFwVersion[0];
    }
 
    inline uint8_t MmuFwVersionMinor() const {
        return mmuFwVersion[1];
    }
 
    inline uint8_t MmuFwVersionRevision() const {
        return mmuFwVersion[2];
    }
 
    constexpr uint8_t RetryAttempts() const { return retryAttempts; }
 
    void DecrementRetryAttempts();
 
    void ResetRetryAttempts();
 
    void ResetCommunicationTimeoutAttempts();
 
    constexpr bool InAutoRetry() const { return inAutoRetry; }
    void SetInAutoRetry(bool iar) {
        inAutoRetry = iar;
    }
 
    inline void SetPrinterError(ErrorCode ec) {
        explicitPrinterError = ec;
    }
    inline void ClearPrinterError() {
        explicitPrinterError = ErrorCode::OK;
    }
    inline bool IsPrinterError() const {
        return explicitPrinterError != ErrorCode::OK;
    }
    inline ErrorCode PrinterError() const {
        return explicitPrinterError;
    }
#ifndef UNITTEST
private:
#endif
    StepStatus ExpectingMessage();
    void SendMsg(RequestMsg rq);
    void SendWriteMsg(RequestMsg rq);
    void SwitchToIdle();
    StepStatus SuppressShortDropOuts(const char *msg_P, StepStatus ss);
    StepStatus HandleCommunicationTimeout();
    StepStatus HandleProtocolError();
    bool Elapsed(uint32_t timeout) const;
    void RecordUARTActivity();
    void RecordReceivedByte(uint8_t c);
    void FormatLastReceivedBytes(char *dst);
    void FormatLastResponseMsgAndClearLRB(char *dst);
    void LogRequestMsg(const uint8_t *txbuff, uint8_t size);
    void LogError(const char *reason_P);
    void LogResponse();
    StepStatus SwitchFromIdleToCommand();
    void SwitchFromStartToIdle();
 
    ErrorCode explicitPrinterError;
 
    enum class State : uint_fast8_t {
        Stopped,      
        InitSequence, 
        Running       
    };
 
    enum class Scope : uint_fast8_t {
        Stopped,
        StartSeq,
        DelayedRestart,
        Idle,
        Command
    };
    Scope currentScope;
 
    // basic scope members
    bool ExpectsResponse() const { return ((uint8_t)scopeState & (uint8_t)ScopeState::NotExpectsResponse) == 0; }
 
    enum class ScopeState : uint_fast8_t {
        S0Sent, // beware - due to optimization reasons these SxSent must be kept one after another
        S1Sent,
        S2Sent,
        S3Sent,
        QuerySent,
        CommandSent,
        FilamentSensorStateSent,
        Reading8bitRegisters,
        Reading16bitRegisters,
        WritingInitRegisters,
        ButtonSent,
        ReadRegisterSent, // standalone requests for reading registers - from higher layers
        WriteRegisterSent,
 
        // States which do not expect a message - MSb set
        NotExpectsResponse = 0x80,
        Wait = NotExpectsResponse + 1,
        Ready = NotExpectsResponse + 2,
        RecoveringProtocolError = NotExpectsResponse + 3,
    };
 
    ScopeState scopeState; 
 
    // StepStatus ProcessFINDAReqSent(StepStatus finishedRV, State nextState);
 
    // StepStatus ProcessStatisticsReqSent(StepStatus finishedRV, State nextState);
 
    void CheckAndReportAsyncEvents();
    void SendQuery();
    void StartReading8bitRegisters();
    void ProcessRead8bitRegister();
    void StartReading16bitRegisters();
    ScopeState ProcessRead16bitRegister(ProtocolLogic::ScopeState stateAtEnd);
    void StartWritingInitRegisters();
    bool ProcessWritingInitRegister();
    void SendAndUpdateFilamentSensor();
    void SendButton(uint8_t btn);
    void SendVersion(uint8_t stage);
    void SendReadRegister(uint8_t index, ScopeState nextState);
    void SendWriteRegister(uint8_t index, uint16_t value, ScopeState nextState);
 
    StepStatus ProcessVersionResponse(uint8_t stage);
 
    StepStatus ScopeStep();
 
    static constexpr uint8_t maxRetries = 6;
    uint8_t retries;
 
    void StartSeqRestart();
    void DelayedRestartRestart();
    void IdleRestart();
    void CommandRestart();
 
    StepStatus StartSeqStep();
    StepStatus DelayedRestartWait();
    StepStatus IdleStep();
    StepStatus IdleWait();
    StepStatus CommandStep();
    StepStatus CommandWait();
    StepStatus StoppedStep() { return Processing; }
 
    StepStatus ProcessCommandQueryResponse();
 
    inline void SetRequestMsg(RequestMsg msg) {
        rq = msg;
    }
    inline const RequestMsg &ReqMsg() const { return rq; }
    RequestMsg rq = RequestMsg(RequestMsgCodes::unknown, 0);
 
    RequestMsg plannedRq;
 
    void PlanGenericRequest(RequestMsg rq);
    bool ActivatePlannedRequest();
 
    uint32_t lastUARTActivityMs;               
    DropOutFilter dataTO;                      
 
    ResponseMsg rsp;                           
 
    State state;                               
 
    Protocol protocol;                         
 
    std::array<uint8_t, 16> lastReceivedBytes; 
    uint8_t lrb;
 
    MMU2Serial *uart;          
 
    ErrorCode errorCode;       
    ProgressCode progressCode; 
    Buttons buttonCode;        
 
    uint8_t lastFSensor;       
 
#ifndef __AVR__
    uint8_t txbuff[Protocol::MaxRequestSize()]; 
#endif
 
    // 8bit registers
    static constexpr uint8_t regs8Count = 3;
    static_assert(regs8Count > 0); // code is not ready for empty lists of registers
    static const Register regs8Addrs[regs8Count] PROGMEM;
    uint8_t regs8[regs8Count] = { 0, 0, 0 };
 
    // 16bit registers
    static constexpr uint8_t regs16Count = 2;
    static_assert(regs16Count > 0); // code is not ready for empty lists of registers
    static const Register regs16Addrs[regs16Count] PROGMEM;
    uint16_t regs16[regs16Count] = { 0, 0 };
 
    // 8bit init values to be sent to the MMU after line up
    static constexpr uint8_t initRegs8Count = 2;
    static_assert(initRegs8Count > 0); // code is not ready for empty lists of registers
    static const Register initRegs8Addrs[initRegs8Count] PROGMEM;
    uint8_t initRegs8[initRegs8Count];
 
    uint8_t regIndex;
 
    uint8_t mmuFwVersion[3] = { 0, 0, 0 };
    uint16_t mmuFwVersionBuild;
 
    uint8_t retryAttempts;
    bool inAutoRetry;
 
    friend class MMU2;
};
 
} // namespace MMU2