SerialModemBase.h

 
#pragma once
#include <Arduino.h>
 
enum class ModemError
{
    Ok,             
    Busy,           
    InvalidArg,     
    FailLbt,        
    Fail,           
    BufferTooSmall, 
    Timeout         
};
 
enum class ModemParseResult
{
    Parsing,             
    Garbage,             
    Overflow,            
    FinishedCmdResponse, 
    FinishedDrResponse   
};
 
enum class CommandType
{
    None,
    Simple,  
    NvmSave, 
    DataTx   
};
 
struct ModemCommand
{
    CommandType type;        
    char cmdBuffer[48];      
    const uint8_t *pPayload; 
    uint8_t payloadLen;      
    char suffix[48];         
    uint32_t timeoutMs;      
};
 
// --- Debug Configuration ---
// To enable debug prints, define ENABLE_SERIAL_MODEM_DEBUG in your project
// #define ENABLE_SERIAL_MODEM_DEBUG
 
#ifdef ENABLE_SERIAL_MODEM_DEBUG
#define SM_DEBUG_PRINT(...) this->dbgPrint(__VA_ARGS__)
#define SM_DEBUG_PRINTLN(...) this->dbgPrintln(__VA_ARGS__)
#define SM_DEBUG_PRINTF(...) this->dbgPrintf(__VA_ARGS__)
#define SM_DEBUG_WRITE(...) this->dbgWrite(__VA_ARGS__)
#else
#define SM_DEBUG_PRINT(...) \
    do                      \
    {                       \
    } while (0)
#define SM_DEBUG_PRINTLN(...) \
    do                        \
    {                         \
    } while (0)
#define SM_DEBUG_PRINTF(...) \
    do                       \
    {                        \
    } while (0)
#define SM_DEBUG_WRITE(...) \
    do                      \
    {                       \
    } while (0)
#endif
 
class SerialModemBase
{
public:
    SerialModemBase();
    virtual ~SerialModemBase() = default;
 
    void setDebugStream(Stream *debugStream);
 
    void update();
 
    bool isIdle() const;
 
    bool isLastCommandComplete() const { return _lastCmdComplete; }
 
    ModemError getLastCommandResult() const { return _lastCmdResult; }
 
    const uint8_t *getRxBuffer() const { return _rxBuffer; }
    uint16_t getRxIndex() const { return _rxIndex; }
 
    bool isQueueFull() const;
 
    bool isQueueEmpty() const;
 
    uint8_t getQueueCount() const;
 
protected:
#ifdef ENABLE_SERIAL_MODEM_DEBUG
    template <typename... Args>
    void dbgPrint(Args... args)
    {
        if (_debugStream)
        {
            _debugStream->print(getLogPrefix());
            _debugStream->print(args...);
        }
    }
    template <typename... Args>
    void dbgPrintln(Args... args)
    {
        if (_debugStream)
        {
            _debugStream->print(getLogPrefix());
            _debugStream->println(args...);
        }
    }
    template <typename... Args>
    void dbgPrintf(Args... args)
    {
        if (_debugStream)
        {
            _debugStream->print(getLogPrefix());
            _debugStream->printf(args...);
        }
    }
    template <typename... Args>
    void dbgWrite(Args... args)
    {
        if (_debugStream)
            _debugStream->write(args...);
    }
#endif
 
    static constexpr char CD_WRITE_OK_RESPONSE[] = "*WR=PS";
    static constexpr size_t CD_WRITE_OK_RESPONSE_LEN = 6;
    static constexpr char CD_VAL_ON[] = "ON";
    static constexpr char CD_VAL_OFF[] = "OF";
    static constexpr char CD_CMD_WRITE_SUFFIX[] = "/W";
 
    // --- Initialization ---
    void initSerial(Stream &stream);
 
    // --- Command Queueing (For Derived Classes) ---
 
    ModemError enqueueCommand(const char *cmd, CommandType type, uint32_t timeoutMs = 1000);
 
    ModemError enqueueTxCommand(const char *cmdHeader, const uint8_t *payload, uint8_t len, const char *suffix = nullptr, uint32_t timeoutMs = 2000);
 
    // --- Synchronous Wrappers (Implemented via update() loop) ---
    // These replace the old blocking implementations but keep the same signature for API compatibility.
 
    ModemError setByteValue(const char *cmd, uint8_t value, bool save, const char *respPrefix, size_t respLen);
 
    ModemError getByteValue(const char *cmd, uint8_t *pValue, const char *respPrefix, size_t respLen);
 
    ModemError setBoolValue(const char *baseCmd, bool enabled, bool save, const char *respPrefix);
 
    ModemError getBoolValue(const char *cmd, bool *pValue, const char *respPrefix);
 
    ModemError sendRawCommand(const char *command, char *responseBuffer, size_t bufferSize, uint32_t timeoutMs);
 
    ModemError waitForSyncComplete(uint32_t timeoutMs);
 
    // --- Low-Level I/O ---
    void writeString(const char *str, bool printPrefix = true);
    void writeData(const uint8_t *data, size_t len);
    int readByte();
    void unreadByte(uint8_t c);
    void clearUnreadByte();
    void flushGarbage(char keepChar = '*');
 
    // --- Timeout Management ---
    void startTimeout(uint32_t ms);
    bool isTimeout();
 
    // --- Parsing Helpers ---
    static bool parseHex(const uint8_t *pData, size_t len, uint32_t *pResult);
    static bool parseDec(const uint8_t *pData, size_t len, uint32_t *pResult);
    ModemError parseResponseHex(const uint8_t *buffer, size_t length, const char *prefix, uint8_t hexDigits, uint32_t *pResult);
    ModemError parseResponseDec(const uint8_t *buffer, size_t length, const char *prefix, const char *suffix, size_t suffixLen, int32_t *pResult);
 
    // --- Virtual Methods (To be implemented by Derived Classes) ---
    virtual ModemParseResult parse() = 0;
    virtual void onRxDataReceived() = 0;
    virtual const char *getLogPrefix() const = 0;
 
    virtual void onCommandComplete(ModemError result) {}
 
protected:
    // --- String Helpers (with bounds checking) ---
    static char *appendStr(char *dest, const char *src, const char *destEnd);
    static char *appendHex2(char *dest, uint8_t val, const char *destEnd);
 
    // Template helpers for automatic size deduction
    template <size_t N>
    static char *appendStr(char (&destBuf)[N], char *currentPtr, const char *src)
    {
        return appendStr(currentPtr, src, destBuf + N);
    }
    template <size_t N>
    static char *appendHex2(char (&destBuf)[N], char *currentPtr, uint8_t val)
    {
        return appendHex2(currentPtr, val, destBuf + N);
    }
 
    Stream *_uart = nullptr;
    Stream *_debugStream = nullptr;
 
    // Shared Receive Buffer (Unified)
    static constexpr size_t RX_BUFFER_SIZE = 300;
    uint8_t _rxBuffer[RX_BUFFER_SIZE];
    uint16_t _rxIndex = 0;
 
    int16_t _oneByteBuf = -1;
    bool _debugRxNewLine = true;
 
private:
    // --- Internal State Machine ---
    enum class State
    {
        Idle,               
        Sending,            
        WaitingResponse,    
        WaitingSaveResponse 
    };
    State _state = State::Idle;
 
    // --- Command Queue ---
    static constexpr uint8_t QUEUE_SIZE = 8;
    ModemCommand _commandQueue[QUEUE_SIZE];
    volatile uint8_t _queueHead = 0;
    volatile uint8_t _queueTail = 0;
 
    ModemCommand _currentCmd; // Currently executing command
 
    // --- Sync/Result State ---
    volatile bool _lastCmdComplete = true;
    volatile ModemError _lastCmdResult = ModemError::Ok;
 
    // Timeout state
    bool _bTimeout = true;
    uint32_t _startTime = 0;
    uint32_t _timeOutDuration = 0;
 
    ModemError enqueueInternal(const char *cmd, CommandType type, const uint8_t *payload, uint8_t len, const char *suffix, uint32_t timeoutMs);
};