scpi.h

Go to the documentation of this file.

 
#ifndef SCPI_H
#define SCPI_H
 
#include <Ethernet.h>
#include "config.h"   // defines SCPI_HASH_TYPE — must precede the parser include below
#define VREKRER_SCPI_PARSER_NO_IMPL
#include "Vrekrer_scpi_parser.h"
#include "stepper.h"

class SCPI {
    public:

    SCPI();

    void setup();

    void processEthernet();

    void processSerial();

    void PrintDebugInfo(Stream& interface);

    void logError(int code, const char* message);
    
    const char* getError();

    int getPort();

    void reinitEthernet();

    void printSessionList(Stream& interface);

    void printSessionLog(Stream& interface);

    void printSocketList(Stream& interface);

    void printSystemDiagnostics(Stream& interface);

    void printAllHeaders(Stream& interface);

    void printHeaderSyntax(Stream& interface, const char* header);
 
    private:
    void registerCommands();
 
    EthernetServer* scpi_server = nullptr;
    SCPI_Parser my_instrument;
 
    // Hardware ceiling: the W5500 has 8 sockets, one of which is reserved for LISTEN.
    static const int MAX_SCPI_CLIENTS = 4;
    struct SCPIClient {
        EthernetClient client;
        bool active = false;
        unsigned long connectedAt = 0;   // millis() when this slot was last assigned, for oldest-session eviction
        unsigned long lastActivity = 0;  // millis() of last byte transferred either direction
        unsigned long rxBytes = 0;
        unsigned long txBytes = 0;
        IPAddress remoteIP;              // cached at accept time — client.remoteIP() is unusable once stopped
        uint16_t remotePort = 0;         // cached at accept time
    };
    SCPIClient scpi_clients[MAX_SCPI_CLIENTS];

    class SessionStream : public Stream {
        public:
        SessionStream(SCPIClient& session) : session_(session) {}
        int available() override { return session_.client.available(); }
        int read() override {
            int c = session_.client.read();
            if (c >= 0) {
                session_.rxBytes++;
                session_.lastActivity = millis();
            }
            return c;
        }
        int peek() override { return session_.client.peek(); }
        void flush() override { session_.client.flush(); }
        size_t write(uint8_t b) override {
            size_t n = session_.client.write(b);
            if (n) {
                session_.txBytes += n;
                session_.lastActivity = millis();
            }
            return n;
        }
        size_t write(const uint8_t* buf, size_t size) override {
            size_t n = session_.client.write(buf, size);
            if (n) {
                session_.txBytes += n;
                session_.lastActivity = millis();
            }
            return n;
        }
        private:
        SCPIClient& session_;
    };
 
    // Ring buffer of the last SESSION_LOG_SIZE session closures, for DIAGnostic:SESSion:LOG?.
    static const int SESSION_LOG_SIZE = 16;
    struct SessionCloseLog {
        unsigned long closedAt = 0;
        IPAddress remoteIP;
        uint16_t remotePort = 0;
        char reason[16] = "";
        unsigned long durationMs = 0;
        unsigned long idleMsAtClose = 0;
        unsigned long rxBytes = 0;
        unsigned long txBytes = 0;
    };
    SessionCloseLog sessionLog[SESSION_LOG_SIZE];
    int sessionLogHead = 0;
    int sessionLogCount = 0;
    void logSessionClose(const SCPIClient& slot, const char* reason);
 
    unsigned long linkFlapCount = 0;  // Ethernet PHY link drops observed (LinkON -> not LinkON)
    unsigned long reinitCount = 0;    // number of times reinitEthernet() has been called
    EthernetLinkStatus lastLinkStatus = Unknown;
 
    bool server_started = false;

    struct SCPI_Error {
        int code;
        char message[100];
    };
 
    // Initialize error queue with a fixed size
    SCPI_Error errorQueue[ERROR_QUEUE_SIZE];
    int errorHead = 0;  
    int errorTail = 0;  
    int errorCount = 0; 
    bool queueOverflow = false; 
 
    int port = 0;   
 
};
 
#endif // SCPI_H