neuro fix

examples/Server/Server.ino

@@ -11,8 +11,7 @@ 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 секунды)
@@ -30,7 +29,6 @@ void serverHandler(EthernetClient client)
     Serial.println(client.getSocketNumber());
         processReceivedData(buf, len);
 
-
     // // Обработка каждого 4-байтового пакета
     // for (int i = 0; i < len; i += 4)
     // {
@@ -53,6 +51,7 @@ void serverHandler(EthernetClient client)
 void setup()
 {
     Serial.begin(115200);
+
     // Инициализация SPI и Ethernet
     SPI.begin();
     pinMode(W5500_CS_PIN, OUTPUT);
@@ -60,15 +59,13 @@ 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.enableCloseOnTimeout(false);
+    server.setServerHandler(serverHandler);
-    // server.setServerHandler(serverHandler);
     Serial.print("Server is running at ");
     Serial.println(Ethernet.localIP());
 }
@@ -78,23 +75,6 @@ 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);
@@ -143,35 +123,3 @@ 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

@@ -0,0 +1,135 @@
+#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);
+//     EthernetClient client(sock);
+//     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::begin()
+// {
+//     for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+//     EthernetClient client(sock);
+//     if (client.status() == SnSR::CLOSED) {
+//         socket(sock, SnMR::TCP, _port, 0);
+//         listen(sock);
+//         EthernetClass::_server_port[sock] = _port;
+//         serverSocket = sock;
+//         break;
+//         }
+//     } 
+//     // Serial.println(F("EthernetMaketServer::begin() FAIL"));
+// }
+uint8_t buf[256];
+void EthernetMaketServer::tick()
+{
+    // for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
+    {
+        EthernetClient sclient = available(/* serverSocket */);
+        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();
+            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_();
+}

src/EthernetOverride/Server.cpp0

@@ -1,176 +0,0 @@
-#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,219 +1,30 @@
-#ifndef __SERVER_H__
+#ifndef __MAKET_SERVER_H__
-#define __SERVER_H__
+#define __MAKET_SERVER_H__
+
 #include "../util/config.h"
-#include "utility/socket.h"
+#include "TCP.h"
-#include "utility/w5500.h"
+#include <functional>
-
+class EthernetMaketClient;
-class IServerCallbacks {
+class EthernetMaketServer : public EthernetServer
-public:
+{
-    virtual void onClosed() = 0;
-    virtual void onListen() = 0;
-    virtual void onEstablished() = 0;
-    virtual void onCloseWait() = 0;
-    virtual void onInit() = 0;
-    virtual void onSynSent() = 0;
-    virtual void onSynRecv() = 0;
-    virtual void onFinWait() = 0;
-    virtual void onClosing() = 0;
-    virtual void onTimeWait() = 0;
-    virtual void onLastAck() = 0;
-};
-
-class W5500Server : public IServerCallbacks {
 private:
-    SOCKET socketId;       // Номер сокета, используемого сервером
+    // EthernetClient available();
-    uint16_t port;         // Порт, на котором сервер слушает
+    // void accept(int sock);
-    uint16_t timeout;      // Таймаут ожидания (мс)
+    std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
-    uint8_t maxRetries;    // Количество попыток отправки
+    SOCKET serverSocket = MAX_SOCK_NUM;
 
-    bool closeOnTimeout;   // Флаг отключения по таймауту
+    bool wasConnected;
-    unsigned long lastActivityTime; // Время последней активности
+    // EthernetMaketClient sclient;
-    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)
+    using EthernetServer::EthernetServer;
-        : socketId(socketId), port(port), timeout(timeout), maxRetries(maxRetries), closeOnTimeout(true), inactivityTimeout(inactivityTimeout), lastStatus(0) {
+    // EthernetMaketClient available(int sock);
-        lastActivityTime = millis();
-    }
 
-    void begin() {
+    void setServerHandler(std::function<void(EthernetMaketClient)> handler);
-        // Настройка сокета
+    void resetServerHandler();
-        socket(socketId, SnMR::TCP, port, 0);
+    // void begin() override;
-        setRetransmissionParams(timeout, maxRetries);
+    // void begin(int sock);
-        listen(socketId);
+    void tick();
-    }
-
-    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__
+#endif // __MAKET_SERVER_H__

src/EthernetOverride/Server0.h

@@ -1,36 +0,0 @@
-#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,326 +2,165 @@
 #include "utility/w5500.h"
 #include "utility/socket.h"
 
-////////////////////////////////////////////////////////////////
-
-
 EthernetMaketClient::EthernetMaketClient() {
     _sock = MAX_SOCK_NUM;
-    // Serial.print("SOCK ?? "); Serial.println(_sock);
 }
 
 EthernetMaketClient::EthernetMaketClient(uint8_t sock) {
     _sock = sock;
 }
+
 EthernetMaketClient::EthernetMaketClient(EthernetClient &client) {
     _sock = client.getSocketNumber();
 }
 
-void EthernetMaketClient::tick()
+EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& other) {
-  {
+    if (this == &other) {
-    forEach(
+        return *this; // Защита от самоприсваивания
-        [](EthernetMaketClient& obj) {  
-            obj.tick_();
-        }
-    );
-
     }
 
-////////////////////////////////////////////////////////////////
+    this->lastActivityTime = other.lastActivityTime;
+    this->startConnectionTime = other.startConnectionTime;
+    this->stopStartTime = other.stopStartTime;
+    this->isNonBlocking = other.isNonBlocking;
+    this->connectStatus = other.connectStatus;
+    this->dstIP = other.dstIP;
+    this->dstPort = other.dstPort;
+    this->dataPtr = other.dataPtr;
+    this->dataSize = other.dataSize;
+    this->onSendSuccess = other.onSendSuccess;
+    this->_sock = other._sock;
+
+    const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE;
+
+    return *this;
+}
 
 ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16_t port) {
     dstIP = ip;
     dstPort = port;
 
-    // if(connectStatus == CONNECT_IDLE){
-    //     connectStatus = CONNECT_START;
-    // }
-
     if (_sock != MAX_SOCK_NUM) {
         uint8_t status_ = status();
         switch (status_) {
-            case SnSR::CLOSED:
-                Serial.println(F("connectNonBlock(): CONNECT_FAIL (CLOSED)"));
-                _sock = MAX_SOCK_NUM;
-                return CONNECT_FAIL;
-                break;
             case SnSR::ESTABLISHED:
-                Serial.println(F("connectNonBlock(): CONNECT_SUCCESS (ESTABLISHED)"));
+                connectStatus = CONNECT_SUCCESS;
                 return CONNECT_SUCCESS;
+            case SnSR::CLOSED:
+            case SnSR::CLOSE_WAIT:
+                close(); // Освобождаем сокет перед попыткой нового подключения
                 break;
             default:
-                // Serial.println(F("connectNonBlock(): CONNECT_CONNECTING (Default)"));
                 return CONNECT_CONNECTING;
-                break;
         }
     }
 
     for (int i = 0; i < MAX_SOCK_NUM; i++) {
         uint8_t s = w5500.readSnSR(i);
-        if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
+        if (s == SnSR::CLOSED || s == SnSR::CLOSE_WAIT) {
             _sock = i;
-            Serial.print("SOCK <- "); Serial.println(_sock);
             break;
-
-            //todo if (s == SnSR::LISTEN){ выполнить приём и занять на время отправки сокет прослушивания }
         }
     }
 
     if (_sock == MAX_SOCK_NUM) {
-        Serial.println(F("connectNonBlock(): CONNECT_FAIL (No available socket)"));
+        connectStatus = CONNECT_FAIL;
         return CONNECT_FAIL;
     }
 
-    Serial.print("sock: ");
-    Serial.println(_sock);
-
     _srcport++;
     if (_srcport == 0) _srcport = 1024;
     socket(_sock, SnMR::TCP, _srcport, 0);
 
     if (!::connect(_sock, rawIPAddress(ip), port)) {
-        Serial.println(F("connectNonBlock(): CONNECT_FAIL (Connect failed)"));
         _sock = MAX_SOCK_NUM;
+        connectStatus = CONNECT_FAIL;
         return CONNECT_FAIL;
     }
 
-    Serial.println(F("connectNonBlock(): CONNECT_CONNECTING (Connection initiated)"));
+    connectStatus = CONNECT_CONNECTING;
     return CONNECT_CONNECTING;
 }
 
+void EthernetMaketClient::tick_() {
+    if (_sock == MAX_SOCK_NUM) {
+        connectStatus = CONNECT_IDLE;
+        return;
+    }
 
-bool EthernetMaketClient::canWriteIntoConnection(size_t size) const {
+    uint8_t s = w5500.readSnSR(_sock);
-    return connectStatus == CONNECT_CONNECTED /* && w5500.getTXFreeSize(_sock) >= size */;
+
+    switch (s) {
+        case SnSR::CLOSED:
+            connectStatus = (connectStatus == CONNECT_CONNECTING) ? CONNECT_FAIL : CONNECT_STOP_WAITING;
+            close();
+            break;
+        case SnSR::ESTABLISHED:
+            if (connectStatus != CONNECT_CONNECTED) {
+                connectStatus = CONNECT_SUCCESS;
+            }
+            break;
+        case SnSR::CLOSE_WAIT:
+            connectStatus = CONNECT_STOP_START;
+            disconnect();
+            break;
+        case SnSR::FIN_WAIT:
+        case SnSR::CLOSING:
+        case SnSR::TIME_WAIT:
+        case SnSR::LAST_ACK:
+            close();
+            connectStatus = CONNECT_STOP_WAITING;
+            break;
+        default:
+            break;
+    }
+
+    // Проверка активности и таймаутов
+    if (connectStatus == CONNECT_CONNECTED) {
+        if (millis() - lastActivityTime > timeout) {
+            connectStatus = CONNECT_STOP_START;
+            disconnect();
+        }
+    } else if (connectStatus == CONNECT_CONNECTING) {
+        if (millis() - startConnectionTime >= connectionTimeout) {
+            connectStatus = CONNECT_FAIL;
+            close();
+        }
+    }
 }
 
 void EthernetMaketClient::disconnect() {
-  if (_sock == MAX_SOCK_NUM)
+    if (_sock != MAX_SOCK_NUM) {
-    return;
         ::disconnect(_sock);
     }
+}
 
 void EthernetMaketClient::close() {
-  if (_sock == MAX_SOCK_NUM)
+    if (_sock != MAX_SOCK_NUM) {
-    return;
         ::close(_sock);
         _sock = MAX_SOCK_NUM;
     }
-
-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 [] Пересмотреть стейт машину перевести на нативные статусы
+void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonBlock) {
-    switchLabel:
+    dstIP = ip;
-    switch (connectStatus)
+    dstPort = port;
-    {
+    isNonBlocking = nonBlock;
-    case CONNECT_START:
+    connectStatus = CONNECT_START;
-        Serial.println("CONNECT_START");
     startConnectionTime = millis();
-        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)
-        {  
-            connectStatus = CONNECT_FAIL;
-            break;
-        }
-        break;
-    case CONNECT_FAIL:
-        Serial.println("CONNECT_FAIL");
-        Serial.print("Failed to connect to server in ");
-        Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode");
-        Serial.println("\n");
-        connectStatus = CONNECT_STOP_START;
-        break;
-    case CONNECT_SUCCESS:
-        Serial.println("CONNECT_SUCCESS");
-        Serial.print("Connected to server in ");
-        Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode");
-        lastActivityTime = millis();
-        connectStatus = CONNECT_CONNECTED;
-
-            lastActivityTime = millis(); // Обновляем время последней активности
-
-        break;
-    case CONNECT_CONNECTED:
-
-        //! Передача пакетов
-        dataWrite();
-        //! Передача завершена
-
-        if (!connected())
-        {
-            Serial.println("Client disconnected");
-            connectStatus = CONNECT_STOP_START;
-        }
-
-        // Закрытие соединения по таймеру неактивности
-        // if (connected() && (millis() - lastActivityTime > timeout))
-        // {
-        //     Serial.println("Connection closed due to inactivity");
-        //     connectStatus = CONNECT_STOP_START;
-        //     goto switchLabel;
-        // }
-        break;
-
-    case CONNECT_STOP_START:
-        Serial.println("CONNECT_STOP_START");
-        dstIP = IPAddress(0,0,0,0);
-        dstPort = 0;
-        disconnect(); 
-        stopStartTime = millis();
-        connectStatus = CONNECT_STOP_WAITING;
-        Serial.println("CONNECT_STOP_WAITING");
-    break;
-
-    case CONNECT_STOP_WAITING:
-        if (millis() - stopStartTime >= stopTimeout) {
-            close(); // Окончательное закрытие сокета после таймаута
-            connectStatus = CONNECT_IDLE;
-        } else {
-            // Проверяем состояние сокета для завершения разрыва
-            uint8_t status_ = status();
-            if (status_ == SnSR::CLOSED || status_ == SnSR::CLOSE_WAIT) {
-                close(); // Закрываем при достижении состояния
-                connectStatus = CONNECT_IDLE;
-            }
-        }
-        if(connectStatus == CONNECT_IDLE) {
-            Serial.println("CONNECT_IDLE\n\n");
-        }
-        break;
-
-    case CONNECT_IDLE:
-        // if(dataSize){
-        //     connectStatus = CONNECT_START;
-        // }
-        break;
-
-    default:
-        break;
-    }
-//********************************************************
-    switch (connectStatus)
-    {
-    case CONNECT_START:
-    case CONNECT_CONNECTING:
-        if (isNonBlocking)
-        {
-            connectStatus = connectNonBlock(dstIP, dstPort);
-        }
-        else
-        {
-            connectStatus = (ConnectionStatusSimple)connect(dstIP, dstPort);
-        }
-        break;
-
-    default:
-        break;
-    }
-//********************************************************
-
-    // //? [*] Проверка наличия доступных данных от сервера
-    // //? проверяется во вне
-    // if (available() > 0)
-    // {
-        
-    // }
-    // //? -------------------------------------------------
 }
 
 bool EthernetMaketClient::dataWrite() {
-    bool ret = false;
+    if (!canWriteIntoConnection(dataSize)) return false;
-    if(dataSize) {
+
-        lastActivityTime = millis();
     if (write(dataPtr, dataSize)) {
         clearData();
-            ret = true;
-        }
         lastActivityTime = millis();
-    }
-    if(ret){
         onSendSuccess();
-    }
+        return true;
-    return ret;
     }
 
-void EthernetMaketClient::clearData(){
+    return false;
-    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) {
@@ -329,17 +168,30 @@ void EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool overr
         this->dataPtr = data;
         this->dataSize = dataSize;
         activityUpdate();
-        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.");
     }
 }
 
+void EthernetMaketClient::clearData() {
+    this->dataPtr = nullptr;
+    this->dataSize = 0;
+}
+
+bool EthernetMaketClient::isDataEmpty() const {
+    return this->dataPtr == nullptr;
+}
+
+bool EthernetMaketClient::canWriteIntoConnection(size_t size) const {
+    return (connectStatus == CONNECT_CONNECTED) && (w5500.getTXFreeSize(_sock) >= size);
+}
+
+void EthernetMaketClient::tick() {
+    forEach([](EthernetMaketClient &client) {
+        client.tick_();
+    });
+}
+
 void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
     onSendSuccess = callback;
 }
@@ -349,49 +201,13 @@ void EthernetMaketClient::resetOnSendSuccess() {
 }
 
 void EthernetMaketClient::stop() {
-    // if(connectStatus!=CONNECT_STOP_WAITING)
     connectStatus = CONNECT_STOP_START;
 }
 
-void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonBlock){
-        dstIP = ip;
-        dstPort = port;
-        isNonBlocking = nonBlock;
-        connectStatus = CONNECT_START;
-};
-
-void EthernetMaketClient::activityUpdate(){
-    lastActivityTime = millis(); 
-}
-
-EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& other) {
-    if (this == &other) {
-        return *this; // Защита от самоприсваивания
-    }
-
-    // Копируем все данные
-    this->lastActivityTime = other.lastActivityTime;
-    this->startConnectionTime = other.startConnectionTime;
-    this->stopStartTime = other.stopStartTime;
-    this->isNonBlocking = other.isNonBlocking;
-    this->connectStatus = other.connectStatus;
-    // this->timeout = other.timeout;
-    // this->connectionTimeout = other.connectionTimeout;
-    // this->stopTimeout = other.stopTimeout;
-    this->dstIP = other.dstIP;
-    this->dstPort = other.dstPort;
-    this->dataPtr = other.dataPtr;
-    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;
 }
+
+void EthernetMaketClient::activityUpdate() {
+    lastActivityTime = millis();
+}

todo

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