WIP old-state: Server/TCP override и резервные копии Server.cpp0/Server0.h — снято с рабочей копии 10.09.2026 (правки с 01.2025)

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AeA1K5dBUKrnoXVwyoVjzq

examples/ClientMultiInstance/ClientMultiInstance.ino

@@ -0,0 +1,150 @@
+#include "EthernetMaket.h" // Предполагается, что этот файл подключает Ethernet3.h
+
+#include <map>
+
+// Настройки для W5500
+#define W5500_CS_PIN PA2 // Пин для CS
+#define SOCKET_NUMBER 0  // Используем сокет 0
+#define SERVER_PORT 1337 // Порт на сервере
+#define CLIENT_PORT 1337 // Порт клиента
+
+#define ServerMac {0xDA, 0x7A, 0xFF, 0x00, 0x00, 0x00}
+#define ServerIP {192, 168, 254, 254}
+
+#define IniMac {0xDA, 0x7A, 0xF0, 0x00, 0x00, 0x00}
+#define IniIP {192, 168, 254, 253}
+
+uint8_t gateway[] = {192, 168, 0, 1}; // Шлюз
+uint8_t subnet[] = {255, 255, 0, 0};  // Маска подсети
+
+uint8_t mac[] = IniMac;    // MAC-адрес
+uint8_t localIP[] = IniIP; // Локальный IP-адрес
+
+uint8_t serverMac[] = ServerMac; // MAC-адрес сервера
+uint8_t serverIP[] = ServerIP;   // IP-адрес сервера
+
+uint8_t buf[512]; // Буфер для передачи данных
+
+uint32_t previousMillis = 0; // Для хранения времени последней отправки
+const long interval = 3750;       // Интервал отправки данных (1.75 секунды)
+uint32_t ttt;
+
+EthernetServer server(SERVER_PORT);
+
+
+struct EthernetMaketClientStruct
+{
+    EthernetMaketClient clientMember; //
+};
+
+std::map<uint16_t, EthernetMaketClientStruct> clientMap;
+ 
+uint32_t packetCounter = 0;
+uint32_t data1;
+uint32_t data2;
+
+void setup()
+{
+    Serial.begin(115200);
+    pinMode(LED_BUILTIN, OUTPUT);
+    Ethernet.setCsPin(W5500_CS_PIN);
+    Ethernet.init();
+
+    // Настройка Ethernet с указанием статических параметров
+    Ethernet.begin(mac, localIP, subnet, gateway, gateway);
+
+
+    EthernetMaketClientStruct c1;
+    EthernetMaketClientStruct c2;
+    clientMap.insert({1, c1});
+    clientMap.insert({2, c2});
+}
+
+void loop()
+{
+    EthernetMaketClient::tick();
+    uint32_t currentMillis = millis();
+    if (currentMillis - ttt > 25)
+    {
+        digitalToggle(PC13);
+        ttt = currentMillis; // Обновляем время
+    }
+
+    if (currentMillis - previousMillis >= interval)
+    {
+        previousMillis = currentMillis;
+
+        Serial.println("connectNonBlock");
+        clientMap[1].clientMember.startConnection(serverIP, SERVER_PORT);
+        clientMap[2].clientMember.startConnection(serverIP, SERVER_PORT);
+
+
+        //* for single packets
+        Serial.print("Sending packet ONE: ");
+        data1 = packetCounter;
+        clientMap[1].clientMember.dataWrite((uint8_t *)&data1, sizeof(data1));
+        for (size_t j = 0; j < sizeof(data1); j++)
+        {
+            Serial.print(((uint8_t *)&data1)[j], HEX);
+            Serial.print(" ");
+        }
+        Serial.println();
+
+        packetCounter++;
+        data2 = packetCounter;
+
+        Serial.print("Sending packet TWO: ");
+        clientMap[2].clientMember.dataWrite((uint8_t *)&data2, sizeof(data2));
+        for (size_t j = 0; j < sizeof(data2); j++)
+        {
+            Serial.print(((uint8_t *)&data2)[j], HEX);
+            Serial.print(" ");
+        }
+        Serial.println();
+
+
+
+
+        packetCounter++;
+
+
+    }
+
+
+if(clientMap[1].clientMember.available()>0){
+    byte response[16];
+        int len = clientMap[1].clientMember.read(response, sizeof(response));
+
+        if (len == 16)
+        {
+            // Проверка контрольной суммы
+            uint8_t checksum = 0;
+            for (int i = 0; i < 15; i++)
+            {
+                checksum += response[i];
+            }
+
+            Serial.print("RX: ");
+            for (int i = 0; i < 16; i++)
+            {
+                Serial.print(response[i], HEX);
+                Serial.print(" ");
+            }
+
+            if (response[15] == checksum)
+            {
+                Serial.println("Checksum is OK");
+            }
+            else
+            {
+                Serial.println("Checksum is ERROR");
+            }
+            clientMap[1].clientMember.activityUpdate(); // Обновляем время последней активности
+        }
+        else
+        {
+            Serial.println("Received an incomplete response");
+        }
+}
+
+}

examples/Server/Server.ino

@@ -11,7 +11,8 @@ byte ip[] = {192, 168, 254, 254};                  // IP-адрес сервер
 uint8_t gateway[] = {192, 168, 0, 1}; // Шлюз
 uint8_t subnet[] = {255, 255, 0, 0};  // Маска подсети
 
-EthernetMaketServer server(SERVER_PORT); // Создаем сервер на указанном порту
+// EthernetMaketServer server(SERVER_PORT); // Создаем сервер на указанном порту
+W5500Server server(0, SERVER_PORT);
 
 unsigned long previousMillis = 0; // Время последней отправки
 const long interval = 1750;       // Интервал отправки данных (1.75 секунды)
@@ -25,21 +26,26 @@ void serverHandler(EthernetClient client)
     byte buf[512];
     int len = client.read(buf, sizeof(buf));
 
-    // Обработка каждого 4-байтового пакета
+    Serial.print("sock: ");
-    for (int i = 0; i < len; i += 4)
+    Serial.println(client.getSocketNumber());
-    {
+        processReceivedData(buf, len);
-        int packetLen = min(4, len - i); // Определяем длину текущего пакета
+        
-        processReceivedData(buf + i, packetLen);
+
-        for (uint8_t j = 0; j < 3; j++)
+    // // Обработка каждого 4-байтового пакета
-        {
+    // for (int i = 0; i < len; i += 4)
-            sendResponse(client, *(uint32_t *)(buf + i));
+    // {
-        }
+    //     int packetLen = min(4, len - i); // Определяем длину текущего пакета
-        packetCounter++;
+    //     processReceivedData(buf + i, packetLen);
-    }
+    //     for (uint8_t j = 0; j < 3; j++)
+    //     {
+    //         sendResponse(client, *(uint32_t *)(buf + i));
+    //     }
+    //     packetCounter++;
+    // }
 
     //!-----------------
     Serial.println("DONE");
-    client.stop();
+    // client.stop();
     Serial.println();
     Serial.println();
 }
@@ -47,7 +53,6 @@ void serverHandler(EthernetClient client)
 void setup()
 {
     Serial.begin(115200);
-
     // Инициализация SPI и Ethernet
     SPI.begin();
     pinMode(W5500_CS_PIN, OUTPUT);
@@ -55,13 +60,15 @@ void setup()
     digitalWrite(W5500_CS_PIN, HIGH);
 
     // Инициализация Ethernet
+    w5500.softReset();
     Ethernet.setCsPin(W5500_CS_PIN); // Установка пина CS для W5500
     Ethernet.init();
     Ethernet.begin(mac, ip, subnet, gateway, gateway);
 
     // Запуск сервера
     server.begin();
-    server.setServerHandler(serverHandler);
+    server.enableCloseOnTimeout(false);
+    // server.setServerHandler(serverHandler);
     Serial.print("Server is running at ");
     Serial.println(Ethernet.localIP());
 }
@@ -71,6 +78,23 @@ void loop()
     server.tick();
     uint32_t currentMillis = millis();
 
+    if(Serial.available()){
+        uint8_t in = Serial.read();
+        switch (in)
+        {
+        case 's':
+            // server.printSocketsState();
+            printSocketsState();
+            break;
+        case 'b':
+            // server.begin(7);
+            break;
+        
+        default:
+            break;
+        }
+    }
+
     if (currentMillis - ttt > 75)
     {
         digitalToggle(PC13);
@@ -119,3 +143,35 @@ volatile void sendResponse(EthernetClient &client, uint32_t packetCount)
     }
     Serial.println();
 }
+
+void printSocketsState(){
+    // if(s.length() > 0)
+    //     Serial.println(s);
+    for (int i = 0; i < MAX_SOCK_NUM; i++) {
+                uint8_t s = w5500.readSnSR(i);
+                String state = "";
+                switch (s) {
+                    case 0x00: state = "CLOSED"; break;
+                    case 0x13: state = "INIT"; break;
+                    case 0x14: state = "LISTEN"; break;
+                    case 0x15: state = "SYNSENT"; break;
+                    case 0x16: state = "SYNRECV"; break;
+                    case 0x17: state = "ESTABLISHED"; break;
+                    case 0x18: state = "FIN_WAIT"; break;
+                    case 0x1A: state = "CLOSING"; break;
+                    case 0x1B: state = "TIME_WAIT"; break;
+                    case 0x1C: state = "CLOSE_WAIT"; break;
+                    case 0x1D: state = "LAST_ACK"; break;
+                    case 0x22: state = "UDP"; break;
+                    case 0x32: state = "IPRAW"; break;
+                    case 0x42: state = "MACRAW"; break;
+                    case 0x5F: state = "PPPOE"; break;
+                    default: state = "UNKNOWN"; break;
+            }
+            delay(1);
+            Serial.print("SOCK <- "); 
+            Serial.print(i);
+            Serial.print(" State: ");
+            Serial.println(state);
+        }
+}

src/EthernetOverride/Server.cpp

@@ -1,99 +0,0 @@
-#include "Server.h"
-#include "utility/w5500.h"
-#include "utility/socket.h"
-
-void EthernetMaketServer::setServerHandler(std::function<void(EthernetMaketClient)> handler)
-{
-    serverHandler = handler;
-}
-
-void EthernetMaketServer::resetServerHandler()
-{
-    serverHandler = [](EthernetMaketClient sclient) {};
-}
-
-EthernetMaketClient EthernetMaketServer::available(int sock)
-{
-    accept(sock);
-    EthernetMaketClient client(sock);
-    if (EthernetClass::_server_port[sock] == _port &&
-        (client.status() == SnSR::ESTABLISHED ||
-         client.status() == SnSR::CLOSE_WAIT))
-    {
-        if (client.available())
-        {
-            return client;
-        }
-    }
-    return EthernetMaketClient(MAX_SOCK_NUM);
-}
-
-void EthernetMaketServer::accept(int sock)
-{
-    int listening = 0;
-    EthernetClient client(sock);
-
-    if (EthernetClass::_server_port[sock] == _port)
-    {
-        if (client.status() == SnSR::LISTEN)
-        {
-            listening = 1;
-        }
-        else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
-        {
-            client.stop();
-        }
-    }
-
-    if (!listening)
-    {
-        // begin();
-        begin(sock); // added
-    }
-}
-
-void EthernetMaketServer::begin(int sock)
-{
-    EthernetClient client(sock);
-    if (client.status() == SnSR::CLOSED)
-    {
-        socket(sock, SnMR::TCP, _port, 0);
-        listen(sock);
-        EthernetClass::_server_port[sock] = _port;
-    }
-}
-
-void EthernetMaketServer::begin()
-{
-    EthernetServer::begin();
-}
-
-void EthernetMaketServer::tick()
-{
-    for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
-    {
-        EthernetMaketClient sclient = available(sock);
-        if (sclient.connected() && sclient.available() > 0)
-        {
-            serverHandler(sclient);
-        }
-        // // Закрытие соединения по таймеру неактивности
-        // if (sclient.connected() && (millis() - lastActivityTime > timeout))
-        // {
-        //     Serial.println("Connection closed due to inactivity");
-        //     sclient.stop();
-        // }
-
-        // if (!wasConnected && sclient.connected())
-        // {
-        //     wasConnected[sock] = true;
-        // }
-
-        // if (wasConnected && !sclient.connected())
-        // {
-        //     wasConnected[sock] = false;
-        //     sclient.stop();
-        //     Serial.println("Client disconnected");
-        // }
-    }
-}

src/EthernetOverride/Server.cpp0

@@ -0,0 +1,176 @@
+#include "Server.h"
+#include "utility/w5500.h"
+#include "utility/socket.h"
+
+EthernetMaketServer::EthernetMaketServer(uint16_t port): port(port){};
+
+void EthernetMaketServer::setServerHandler(std::function<void(EthernetMaketClient)> handler)
+{
+    serverHandler = handler;
+}
+
+void EthernetMaketServer::resetServerHandler()
+{
+    serverHandler = [](EthernetMaketClient sclient) {};
+}
+
+EthernetMaketClient EthernetMaketServer::available(int sock)
+{
+    accept(sock);
+    EthernetClient client(6);
+    if (EthernetClass::_server_port[sock] == port &&
+        (client.status() == SnSR::ESTABLISHED ||
+         client.status() == SnSR::CLOSE_WAIT))
+    {
+        if (client.available())
+        {
+            return std::move(EthernetMaketClient(client));
+        }
+    }
+    return std::move(EthernetMaketClient(MAX_SOCK_NUM));
+}
+
+void EthernetMaketServer::accept(int sock)
+{
+    int listening = 0;
+    EthernetClient client(sock);
+
+    if (EthernetClass::_server_port[sock] == port)
+    {
+        if (client.status() == SnSR::LISTEN)
+        {
+            listening = 1;
+        }
+        else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
+        {
+            Serial.println("HARD STOP");
+            client.stop();
+        }
+    }
+
+    if (!listening)
+    {
+        // begin();
+        
+        // begin(sock); // added
+    }
+}
+
+void EthernetMaketServer::begin(int sock)
+{
+    EthernetClient client(sock);
+    if (client.status() == SnSR::CLOSED)
+    {
+        socket(sock, SnMR::TCP, port, 0);
+        listen(sock);
+        EthernetClass::_server_port[sock] = port;
+        serverSocket = sock; 
+        return;
+    } 
+    // Serial.println(F("EthernetMaketServer::begin() FAIL"));
+}
+
+void EthernetMaketServer::tick()
+{
+
+    switch (serverStatus)
+    {
+    // case CLOSED:
+    //      begin(??);
+    //      break;
+
+    // case LISTEN:
+    //      begin(??);
+    //      break;
+    
+    default:
+        break;
+    }
+
+
+
+
+
+    // for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
+    // {
+        
+        EthernetClient sclient = available(7);
+        size_t dataSize;
+        if (sclient.connected() && (dataSize = sclient.available()) > 0)
+        {
+            // Serial.println("Receive!");
+
+            // memset(buf,0x00,sizeof(buf));
+            // sclient.read(buf, sizeof(buf));
+
+            // Serial.print("Received data: ");
+            // for (int i = 0; i < dataSize; i++)
+            // {
+            //     Serial.print(buf[i], HEX);
+            //     Serial.print(" ");
+            // }
+            // Serial.println("\n");
+
+            // sclient.activityUpdate();
+            printSocketsState("sclient.available()");
+            serverHandler(EthernetMaketClient(sclient));
+        }
+
+
+
+
+        // if (!wasConnected && sclient.connected())
+        // {
+        //     wasConnected = true;
+        //     Serial.println("Client connected");
+        // }
+
+        // if (wasConnected && !sclient.connected())
+        // {
+        //     wasConnected = false;
+        //     sclient.stop();
+        //     // begin(serverSocket);
+        //     Serial.println("Client disconnected");
+        // }
+        // // Закрытие соединения по таймеру неактивности
+        // if (sclient.connected() && (millis() - lastActivityTime > timeout))
+        // {
+        //     Serial.println("Connection closed due to inactivity");
+        //     sclient.close();
+        //     // begin(serverSocket);
+        // }
+    // }
+    // sclient.tick_();
+}
+
+void EthernetMaketServer::printSocketsState(String s){
+    if(s.length() > 0)
+        Serial.println(s);
+    for (int i = 0; i < MAX_SOCK_NUM; i++) {
+                uint8_t s = w5500.readSnSR(i);
+                String state = "";
+                switch (s) {
+                    case 0x00: state = "CLOSED"; break;
+                    case 0x13: state = "INIT"; break;
+                    case 0x14: state = "LISTEN"; break;
+                    case 0x15: state = "SYNSENT"; break;
+                    case 0x16: state = "SYNRECV"; break;
+                    case 0x17: state = "ESTABLISHED"; break;
+                    case 0x18: state = "FIN_WAIT"; break;
+                    case 0x1A: state = "CLOSING"; break;
+                    case 0x1B: state = "TIME_WAIT"; break;
+                    case 0x1C: state = "CLOSE_WAIT"; break;
+                    case 0x1D: state = "LAST_ACK"; break;
+                    case 0x22: state = "UDP"; break;
+                    case 0x32: state = "IPRAW"; break;
+                    case 0x42: state = "MACRAW"; break;
+                    case 0x5F: state = "PPPOE"; break;
+                    default: state = "UNKNOWN"; break;
+            }
+        
+            Serial.print("SOCK <- "); 
+            Serial.print(i);
+            Serial.print(" State: ");
+            Serial.println(state);
+        }
+}

src/EthernetOverride/Server.h

@@ -1,27 +1,219 @@
-#ifndef __MAKET_SERVER_H__
+#ifndef __SERVER_H__
-#define __MAKET_SERVER_H__
+#define __SERVER_H__
-
 #include "../util/config.h"
-#include "TCP.h"
+#include "utility/socket.h"
-#include <functional>
+#include "utility/w5500.h"
-class EthernetMaketClient;
-class EthernetMaketServer : public EthernetServer
-{
-private:
-    EthernetClient available();
-    void accept(int sock);
-    std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
-    bool wasConnected[MAX_SOCK_NUM];
 
+class IServerCallbacks {
 public:
-    using EthernetServer::EthernetServer;
+    virtual void onClosed() = 0;
-    EthernetMaketClient available(int sock);
+    virtual void onListen() = 0;
-
+    virtual void onEstablished() = 0;
-    void setServerHandler(std::function<void(EthernetMaketClient)> handler);
+    virtual void onCloseWait() = 0;
-    void resetServerHandler();
+    virtual void onInit() = 0;
-    void begin() override;
+    virtual void onSynSent() = 0;
-    void begin(int sock);
+    virtual void onSynRecv() = 0;
-    void tick();
+    virtual void onFinWait() = 0;
+    virtual void onClosing() = 0;
+    virtual void onTimeWait() = 0;
+    virtual void onLastAck() = 0;
 };
 
-#endif // __MAKET_SERVER_H__
+class W5500Server : public IServerCallbacks {
+private:
+    SOCKET socketId;       // Номер сокета, используемого сервером
+    uint16_t port;         // Порт, на котором сервер слушает
+    uint16_t timeout;      // Таймаут ожидания (мс)
+    uint8_t maxRetries;    // Количество попыток отправки
+
+    bool closeOnTimeout;   // Флаг отключения по таймауту
+    unsigned long lastActivityTime; // Время последней активности
+    uint32_t inactivityTimeout; // Таймаут неактивности (мс)
+
+    uint8_t lastStatus;    // Последний статус сокета
+
+public:
+    W5500Server(SOCKET socketId, uint16_t port, uint16_t timeout = 2000, uint8_t maxRetries = 3, uint32_t inactivityTimeout = 500)
+        : socketId(socketId), port(port), timeout(timeout), maxRetries(maxRetries), closeOnTimeout(true), inactivityTimeout(inactivityTimeout), lastStatus(0) {
+        lastActivityTime = millis();
+    }
+
+    void begin() {
+        // Настройка сокета
+        socket(socketId, SnMR::TCP, port, 0);
+        setRetransmissionParams(timeout, maxRetries);
+        listen(socketId);
+    }
+
+    void tick() {
+        uint8_t currentStatus = w5500.readSnSR(socketId);
+
+        if (currentStatus != lastStatus) {
+            lastStatus = currentStatus;
+            switch (currentStatus) {
+            case SnSR::CLOSED:
+                onClosed();
+                break;
+
+            case SnSR::LISTEN:
+                onListen();
+                break;
+
+            case SnSR::ESTABLISHED:
+                onEstablished();
+                break;
+
+            case SnSR::CLOSE_WAIT:
+                onCloseWait();
+                break;
+
+            case SnSR::INIT:
+                onInit();
+                break;
+
+            case SnSR::SYNSENT:
+                onSynSent();
+                break;
+
+            case SnSR::SYNRECV:
+                onSynRecv();
+                break;
+
+            case SnSR::FIN_WAIT:
+                onFinWait();
+                break;
+
+            case SnSR::CLOSING:
+                onClosing();
+                break;
+
+            case SnSR::TIME_WAIT:
+                onTimeWait();
+                break;
+
+            case SnSR::LAST_ACK:
+                onLastAck();
+                break;
+
+            default:
+                break;
+            }
+        }
+
+        if (closeOnTimeout && currentStatus == SnSR::ESTABLISHED && millis() - lastActivityTime > inactivityTimeout) {
+            // Закрываем соединение по таймауту неактивности
+            Serial.println("Connection closed due to inactivity");
+            disconnect(socketId);
+            close(socketId);
+            return;
+        }
+
+        if (currentStatus == SnSR::ESTABLISHED) {
+            handleClient();
+        }
+    }
+
+    void setInactivityTimeout(uint32_t timeout) {
+        inactivityTimeout = timeout;
+    }
+
+    void enableCloseOnTimeout(bool enable) {
+        closeOnTimeout = enable;
+    }
+
+    // Реализация интерфейса IServerCallbacks
+    void onClosed() override {
+        Serial.println("STAT = CLOSED\n");
+        begin();
+    }
+
+    void onListen() override {
+        Serial.println("STAT = LISTEN");
+    }
+
+    void onEstablished() override {
+        Serial.println("STAT = ESTABLISHED");
+        lastActivityTime = millis(); // Сбрасываем таймер
+    }
+
+    void onCloseWait() override {
+        Serial.println("STAT = CLOSE_WAIT");
+        disconnect(socketId);
+        close(socketId);
+    }
+
+    void onInit() override {
+        Serial.println("STAT = INIT");
+    }
+
+    void onSynSent() override {
+        Serial.println("STAT = SYNSENT");
+    }
+
+    void onSynRecv() override {
+        Serial.println("STAT = SYNRECV");
+    }
+
+    void onFinWait() override {
+        Serial.println("STAT = FIN_WAIT");
+    }
+
+    void onClosing() override {
+        Serial.println("STAT = CLOSING");
+    }
+
+    void onTimeWait() override {
+        Serial.println("STAT = TIME_WAIT");
+    }
+
+    void onLastAck() override {
+        Serial.println("STAT = LAST_ACK");
+    }
+
+private:
+    void handleClient() {
+        // Проверяем, есть ли данные для чтения
+        uint16_t size = w5500.getRXReceivedSize(socketId);
+        if (size > 0) {
+            lastActivityTime = millis(); // Сбрасываем таймер по активности
+
+            uint8_t buffer[size];
+            recv(socketId, buffer, size);
+
+            // Вывод данных в шестнадцатеричном формате
+            Serial.println("Received (hex):");
+            for (uint16_t i = 0; i < size; i++) {
+                Serial.print(buffer[i], HEX);
+                Serial.print(" ");
+                if ((i + 1) % 8 == 0) Serial.print("  "); // Разделение каждые 8 байт
+                if ((i + 1) % 16 == 0) Serial.println();    // Разделение на строки по 16 байт
+            }
+            Serial.println();
+
+            // Отправка ответа (если требуется)
+            const char *response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, Client!";
+            sendData((uint8_t *)response, strlen(response));
+            lastActivityTime = millis(); // Сбрасываем таймер по активности
+        }
+    }
+
+    void sendData(uint8_t *data, uint16_t size) {
+        while (size > 0) {
+            uint16_t freeSpace = w5500.getTXFreeSize(socketId);
+            if (freeSpace > 0) {
+                uint16_t chunk = size < freeSpace ? size : freeSpace;
+                send(socketId, data, chunk);
+                data += chunk;
+                size -= chunk;
+                lastActivityTime = millis(); // Сбрасываем таймер по активности
+            }
+        }
+    }
+
+    void setRetransmissionParams(uint16_t timeout, uint8_t retries) {
+        w5500.setRetransmissionTime(timeout);
+        w5500.setRetransmissionCount(retries);
+    }
+};
+
+#endif // __SERVER_H__

src/EthernetOverride/Server0.h

@@ -0,0 +1,36 @@
+#ifndef __MAKET_SERVER_H__
+#define __MAKET_SERVER_H__
+
+#include "../util/config.h"
+#include "TCP.h"
+#include <functional>
+class EthernetMaketClient;
+class EthernetMaketServer /* : public EthernetServer */
+{
+
+protected:
+    uint16_t port;
+    void accept(int sock);
+    std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
+    SOCKET serverSocket = MAX_SOCK_NUM;
+
+    // bool wasConnected;
+    // EthernetMaketClient sclient;
+
+public:
+    // using EthernetServer::EthernetServer;
+
+    EthernetMaketServer(uint16_t);
+
+    EthernetMaketClient available(int sock);
+
+    void setServerHandler(std::function<void(EthernetMaketClient)> handler);
+    void resetServerHandler();
+    // void begin() override;
+    void begin(int sock);
+    void tick();
+
+    void printSocketsState(String s = "");
+};
+
+#endif // __MAKET_SERVER_H__

src/EthernetOverride/TCP.cpp

@@ -2,30 +2,32 @@
 #include "utility/w5500.h"
 #include "utility/socket.h"
 
-std::list<EthernetMaketClient*>& EthernetMaketClient::getInstances() {
+////////////////////////////////////////////////////////////////
-    static std::list<EthernetMaketClient*> instances; // Список создаётся при первом доступе
+
-    return instances;
-}
 
 EthernetMaketClient::EthernetMaketClient() {
     _sock = MAX_SOCK_NUM;
-    getInstances().push_back(this);
+    // Serial.print("SOCK ?? "); Serial.println(_sock);
 }
 
 EthernetMaketClient::EthernetMaketClient(uint8_t sock) {
     _sock = sock;
-    getInstances().push_back(this);
+}
+EthernetMaketClient::EthernetMaketClient(EthernetClient &client) {
+    _sock = client.getSocketNumber();
 }
 
-EthernetMaketClient::~EthernetMaketClient() {
+void EthernetMaketClient::tick()
-    getInstances().remove(this);
+  {
-}
+    forEach(
-
+        [](EthernetMaketClient& obj) {  
-void EthernetMaketClient::tick() {
+            obj.tick_();
-    for (EthernetMaketClient* client : getInstances()) {
-        client->tick_();
         }
-}
+    );
+
+  }
+
+////////////////////////////////////////////////////////////////
 
 ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16_t port) {
     dstIP = ip;
@@ -58,7 +60,10 @@ ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16
         uint8_t s = w5500.readSnSR(i);
         if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
             _sock = i;
+            Serial.print("SOCK <- "); Serial.println(_sock);
             break;
+
+            //todo if (s == SnSR::LISTEN){ выполнить приём и занять на время отправки сокет прослушивания }
         }
     }
 
@@ -85,8 +90,8 @@ ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16
 }
 
 
-bool EthernetMaketClient::isConnected() const {
+bool EthernetMaketClient::canWriteIntoConnection(size_t size) const {
-    return connectStatus == CONNECT_CONNECTED;
+    return connectStatus == CONNECT_CONNECTED /* && w5500.getTXFreeSize(_sock) >= size */;
 }
 
 void EthernetMaketClient::disconnect(){
@@ -103,6 +108,50 @@ void EthernetMaketClient::close(){
 }
 
 void EthernetMaketClient::tick_(){
+    if(_sock != MAX_SOCK_NUM && connectStatus!=CONNECT_CONNECTED && connectStatus!=CONNECT_STOP_WAITING&&connectStatus!=CONNECT_CONNECTING){
+
+        uint8_t s = w5500.readSnSR(_sock);
+        String state = "";
+        switch (s) {
+                case 0x00: state = "CLOSED"; connectStatus = CONNECT_STOP_WAITING; break;
+                case 0x13: state = "INIT"; break;
+                case 0x14: state = "LISTEN"; break;
+                case 0x15: state = "SYNSENT"; break;
+                case 0x16: state = "SYNRECV"; break;
+                case 0x17: state = "ESTABLISHED"; connectStatus = CONNECT_CONNECTED; goto switchLabel; break;
+                case 0x18: state = "FIN_WAIT"; break;
+                case 0x1A: state = "CLOSING"; break;
+                case 0x1B: state = "TIME_WAIT"; break;
+                case 0x1C: state = "CLOSE_WAIT"; connectStatus = CONNECT_STOP_START; break;
+                case 0x1D: state = "LAST_ACK"; break;
+                case 0x22: state = "UDP"; break;
+                case 0x32: state = "IPRAW"; break;
+                case 0x42: state = "MACRAW"; break;
+                case 0x5F: state = "PPPOE"; break;
+                default: state = "UNKNOWN"; break;
+        }
+        String connectStatusStr = "";
+        switch (connectStatus) {
+                case CONNECT_FAIL: connectStatusStr = "CONNECT_FAIL";  break;
+                case CONNECT_SUCCESS: connectStatusStr = "CONNECT_SUCCESS"; break;
+                case CONNECT_CONNECTING: connectStatusStr = "CONNECT_CONNECTING"; break;
+                case CONNECT_START: connectStatusStr = "CONNECT_START"; break;
+                case CONNECT_IDLE: connectStatusStr = "CONNECT_IDLE"; break;
+                case CONNECT_CONNECTED: connectStatusStr = "CONNECT_CONNECTED"; break;
+                case CONNECT_STOP_START: connectStatusStr = "CONNECT_STOP_START"; break;
+                case CONNECT_STOP_WAITING: connectStatusStr = "CONNECT_STOP_WAITING"; break;
+                default: connectStatusStr = "UNKNOWN"; break;
+        }
+        Serial.print("tick_() sock = "); Serial.print(_sock); 
+        Serial.print(" state = ");  
+        Serial.print(state);
+        Serial.print(" connectStatus = ");  
+        Serial.print(connectStatusStr);  
+        Serial.println();
+    }
+
+//todo [] Пересмотреть стейт машину перевести на нативные статусы
+    switchLabel:
     switch (connectStatus)
     {
     case CONNECT_START:
@@ -111,6 +160,35 @@ void EthernetMaketClient::tick_(){
         connectStatus = CONNECT_CONNECTING;
         close();
         Serial.println("CONNECT_CONNECTING...");
+        {
+        for (int i = 0; i < MAX_SOCK_NUM; i++) {
+            uint8_t s = w5500.readSnSR(i);
+            String state = "";
+            switch (s) {
+                case 0x00: state = "CLOSED"; break;
+                case 0x13: state = "INIT"; break;
+                case 0x14: state = "LISTEN"; break;
+                case 0x15: state = "SYNSENT"; break;
+                case 0x16: state = "SYNRECV"; break;
+                case 0x17: state = "ESTABLISHED"; break;
+                case 0x18: state = "FIN_WAIT"; break;
+                case 0x1A: state = "CLOSING"; break;
+                case 0x1B: state = "TIME_WAIT"; break;
+                case 0x1C: state = "CLOSE_WAIT"; break;
+                case 0x1D: state = "LAST_ACK"; break;
+                case 0x22: state = "UDP"; break;
+                case 0x32: state = "IPRAW"; break;
+                case 0x42: state = "MACRAW"; break;
+                case 0x5F: state = "PPPOE"; break;
+                default: state = "UNKNOWN"; break;
+        }
+        
+            Serial.print("SOCK <- "); 
+            Serial.print(i);
+            Serial.print(" State: ");
+            Serial.println(state);
+        }
+    }
         break;
     case CONNECT_CONNECTING:
         if (millis() - startConnectionTime >= connectionTimeout)
@@ -149,11 +227,12 @@ void EthernetMaketClient::tick_(){
         }
 
         // Закрытие соединения по таймеру неактивности
-        if (connected() && (millis() - lastActivityTime > timeout))
+        // if (connected() && (millis() - lastActivityTime > timeout))
-        {
+        // {
-            Serial.println("Connection closed due to inactivity");
+        //     Serial.println("Connection closed due to inactivity");
-            connectStatus = CONNECT_STOP_START;
+        //     connectStatus = CONNECT_STOP_START;
-        }
+        //     goto switchLabel;
+        // }
         break;
 
     case CONNECT_STOP_START:
@@ -212,7 +291,8 @@ void EthernetMaketClient::tick_(){
     }
 //********************************************************
 
-    // //? Проверка наличия доступных данных от сервера
+    // //? [*] Проверка наличия доступных данных от сервера
+    // //? проверяется во вне
     // if (available() > 0)
     // {
         
@@ -225,8 +305,7 @@ bool EthernetMaketClient::dataWrite(){
     if(dataSize) {
         lastActivityTime = millis();
         if(write(dataPtr, dataSize)){
-            dataPtr = nullptr; 
+            clearData();
-            dataSize = 0; // Очищаем размер данных
             ret = true;
         }
         lastActivityTime = millis();
@@ -237,49 +316,30 @@ bool EthernetMaketClient::dataWrite(){
     return ret;
 }
 
+void EthernetMaketClient::clearData(){
+    this->dataPtr = nullptr;
+    this->dataSize = 0;
+}
+bool EthernetMaketClient::isDataEmpty() const{
+    return  this->dataPtr == nullptr;
+}
+
 void EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool override) {
-    if (this->dataSize == 0 || override) {
+    if (this->dataPtr == nullptr || override) {
         this->dataPtr = data;
         this->dataSize = dataSize;
-        if(isConnected()){
+        activityUpdate();
-            dataWrite();
+        Serial.println("Data buffer Saved.");
-        }
+        // if(canWrite(dataSize)){
+        //     dataWrite();
+        // } else {
+        //     Serial.println("W5500 Buffer is full. Write operation is ignored.");
+        // }
     } else {
         Serial.println("Data buffer is not empty. Write operation is ignored.");
     }
 }
 
-
-// bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) {
-//     this->dataPtr = data;
-//     this->dataSize = dataSize;
-//     dstIP = ip;
-//     dstPort = port;
-
-//     switch (connectStatus) {
-//         case CONNECT_CONNECTED:
-//             if(dataWrite()){
-//                 onSendSuccess();
-//             }
-//             // Если подключено, отправляем данные
-//             return true;
-
-//         case CONNECT_STOP_WAITING:
-//         case CONNECT_STOP_START:
-//             return false; // Ожидаем завершения разрыва
-
-//         // case CONNECT_FAIL:
-//         case CONNECT_IDLE:
-//             connectNonBlock(ip, port);
-//             connectStatus = CONNECT_START; // Начинаем новое подключение
-//             return false; // Подключение инициировано
-
-//         default:
-//             return false; // Пока ждём подключения
-//     }
-//     return false;
-// }
-
 void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
     onSendSuccess = callback;
 }
@@ -289,6 +349,7 @@ void EthernetMaketClient::resetOnSendSuccess() {
 }
 
 void EthernetMaketClient::stop(){
+    // if(connectStatus!=CONNECT_STOP_WAITING)
     connectStatus = CONNECT_STOP_START;
 }
 
@@ -323,9 +384,14 @@ EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& o
     this->dataSize = other.dataSize;
     this->onSendSuccess = other.onSendSuccess;
 
+    this->_sock = other._sock;
+    
     // Отключаем исполнение старого клиента
     const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE;
 
     return *this;
 }
 
+ConnectionStatusSimple EthernetMaketClient::getConnectionStatus() const {
+    return connectStatus;
+}

src/EthernetOverride/TCP.h

@@ -4,8 +4,9 @@
 #include <list>
 #include <functional>
 #include "../util/config.h"
+#include "InstanceManager.h"
 
-class EthernetMaketClient : public EthernetClient {
+class EthernetMaketClient : public EthernetClient, public InstanceManager<EthernetMaketClient> {
 protected:
     uint32_t lastActivityTime = 0; // Время последней активности
     const uint16_t timeout = 300;  // Таймаут неактивности в миллисекундах
@@ -25,15 +26,32 @@ protected:
 
     bool dataWrite();
 
-    static std::list<EthernetMaketClient*>& getInstances(); // Ленивое создание списка
+    // static std::list<EthernetMaketClient*>& getInstances(); // Ленивое создание списка
 
-    void tick_();
     ConnectionStatusSimple connectStatus = CONNECT_IDLE; 
 
 public:
     EthernetMaketClient();
     EthernetMaketClient(uint8_t sock);
-    ~EthernetMaketClient();
+    EthernetMaketClient(EthernetClient &client);
+    
+    //     // Move constructor
+    // EthernetMaketClient(EthernetMaketClient&& other) noexcept
+    //     : EthernetClient(std::move(other)), // Move base class
+    //       lastActivityTime(other.lastActivityTime),
+    //       startConnectionTime(other.startConnectionTime),
+    //       stopStartTime(other.stopStartTime),
+    //       onSendSuccess(std::move(other.onSendSuccess)),
+    //       isNonBlocking(other.isNonBlocking),
+    //       dataPtr(other.dataPtr),
+    //       dataSize(other.dataSize),
+    //       dstIP(std::move(other.dstIP)),
+    //       dstPort(other.dstPort),
+    //       connectStatus(other.connectStatus)
+    // {
+    //     other.dataPtr = nullptr; // Reset the source object's pointer
+    //     other.dataSize = 0;
+    // }
 
     EthernetMaketClient& operator=(const EthernetMaketClient& other);
 
@@ -41,18 +59,22 @@ public:
     void startConnection(IPAddress ip, uint16_t port, bool nonBlock = true);
 
     void dataWrite(uint8_t* data, uint16_t dataSize, bool override = false);
-    // bool send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port);
+    void clearData();
+    bool isDataEmpty() const;
 
     void disconnect();
     void close();
     void stop();
-    bool isConnected() const;
+    bool canWriteIntoConnection(size_t = 0) const;
 
     static void tick();
+    void tick_();
 
     void setOnSendSuccess(const std::function<void()>& callback);
     void resetOnSendSuccess();
 
+    ConnectionStatusSimple getConnectionStatus() const;
+
     void activityUpdate();
 };
 

todo

@@ -1 +1,4 @@
-[] Проверить и отладить UDP
+8 статических клиентов для управления таймингами и сессией
+параметры клиентской сессии:
+    
+