neuro fix

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

@@ -25,21 +25,25 @@ void serverHandler(EthernetClient client)
     byte buf[512];
     int len = client.read(buf, sizeof(buf));
 
-    // Обработка каждого 4-байтового пакета
-    for (int i = 0; i < len; i += 4)
-    {
-        int packetLen = min(4, len - i); // Определяем длину текущего пакета
-        processReceivedData(buf + i, packetLen);
-        for (uint8_t j = 0; j < 3; j++)
-        {
-            sendResponse(client, *(uint32_t *)(buf + i));
-        }
-        packetCounter++;
-    }
+    Serial.print("sock: ");
+    Serial.println(client.getSocketNumber());
+        processReceivedData(buf, len);
+
+    // // Обработка каждого 4-байтового пакета
+    // for (int i = 0; i < len; i += 4)
+    // {
+    //     int packetLen = min(4, len - i); // Определяем длину текущего пакета
+    //     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();
 }

src/EthernetOverride/Server.cpp

@@ -12,88 +12,124 @@ 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);
-}
+// 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);
+// 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 (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
-    }
-}
+//     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::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++)
+    // for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
     {
-        EthernetMaketClient sclient = available(sock);
-        if (sclient.connected() && sclient.available() > 0)
+        EthernetClient sclient = available(/* serverSocket */);
+        size_t dataSize;
+        if (sclient.connected() && (dataSize = sclient.available()) > 0)
         {
-            serverHandler(sclient);
+            // 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 (sclient.connected() && (millis() - lastActivityTime > timeout))
-        // {
-        //     Serial.println("Connection closed due to inactivity");
-        //     sclient.stop();
-        // }
+
+
+
 
         // if (!wasConnected && sclient.connected())
         // {
-        //     wasConnected[sock] = true;
+        //     wasConnected = true;
+        //     Serial.println("Client connected");
         // }
 
         // if (wasConnected && !sclient.connected())
         // {
-        //     wasConnected[sock] = false;
+        //     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.h

@@ -8,19 +8,22 @@ class EthernetMaketClient;
 class EthernetMaketServer : public EthernetServer
 {
 private:
-    EthernetClient available();
-    void accept(int sock);
+    // EthernetClient available();
+    // void accept(int sock);
     std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
-    bool wasConnected[MAX_SOCK_NUM];
+    SOCKET serverSocket = MAX_SOCK_NUM;
+
+    bool wasConnected;
+    // EthernetMaketClient sclient;
 
 public:
     using EthernetServer::EthernetServer;
-    EthernetMaketClient available(int sock);
+    // EthernetMaketClient available(int sock);
 
     void setServerHandler(std::function<void(EthernetMaketClient)> handler);
     void resetServerHandler();
-    void begin() override;
-    void begin(int sock);
+    // void begin() override;
+    // void begin(int sock);
     void tick();
 };
 

src/EthernetOverride/TCP.cpp

@@ -2,283 +2,195 @@
 #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);
 }
 
 EthernetMaketClient::EthernetMaketClient(uint8_t sock) {
     _sock = sock;
-    getInstances().push_back(this);
 }
 
-EthernetMaketClient::~EthernetMaketClient() {
-    getInstances().remove(this);
+EthernetMaketClient::EthernetMaketClient(EthernetClient &client) {
+    _sock = client.getSocketNumber();
 }
 
-void EthernetMaketClient::tick() {
-    for (EthernetMaketClient* client : getInstances()) {
-        client->tick_();
+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->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;
             break;
         }
     }
 
     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::isConnected() const {
-    return connectStatus == CONNECT_CONNECTED;
-}
+    uint8_t s = w5500.readSnSR(_sock);
 
-void EthernetMaketClient::disconnect(){
-  if (_sock == MAX_SOCK_NUM)
-    return;
-    ::disconnect(_sock);
-}
-
-void EthernetMaketClient::close(){
-  if (_sock == MAX_SOCK_NUM)
-    return;
-    ::close(_sock);
-    _sock = MAX_SOCK_NUM;
-}
-
-void EthernetMaketClient::tick_(){
-    switch (connectStatus)
-    {
-    case CONNECT_START:
-        Serial.println("CONNECT_START");
-        startConnectionTime = millis();
-        connectStatus = CONNECT_CONNECTING;
-        close();
-        Serial.println("CONNECT_CONNECTING...");
-        break;
-    case CONNECT_CONNECTING:
-        if (millis() - startConnectionTime >= connectionTimeout)
-        {  
-            connectStatus = CONNECT_FAIL;
+    switch (s) {
+        case SnSR::CLOSED:
+            connectStatus = (connectStatus == CONNECT_CONNECTING) ? CONNECT_FAIL : CONNECT_STOP_WAITING;
+            close();
             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;
-        }
-        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;
+        case SnSR::ESTABLISHED:
+            if (connectStatus != CONNECT_CONNECTED) {
+                connectStatus = CONNECT_SUCCESS;
             }
-        }
-        if(connectStatus == CONNECT_IDLE) {
-            Serial.println("CONNECT_IDLE\n\n");
-        }
-        break;
-
-    case CONNECT_IDLE:
-        // if(dataSize){
-        //     connectStatus = CONNECT_START;
-        // }
-        break;
-
-    default:
-        break;
+            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;
     }
-//********************************************************
-    switch (connectStatus)
-    {
-    case CONNECT_START:
-    case CONNECT_CONNECTING:
-        if (isNonBlocking)
-        {
-            connectStatus = connectNonBlock(dstIP, dstPort);
-        }
-        else
-        {
-            connectStatus = (ConnectionStatusSimple)connect(dstIP, dstPort);
-        }
-        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();
+        }
     }
-//********************************************************
-
-    // //? Проверка наличия доступных данных от сервера
-    // if (available() > 0)
-    // {
-        
-    // }
-    // //? -------------------------------------------------
 }
 
-bool EthernetMaketClient::dataWrite(){
-    bool ret = false;
-    if(dataSize) {
-        lastActivityTime = millis();
-        if(write(dataPtr, dataSize)){
-            dataPtr = nullptr; 
-            dataSize = 0; // Очищаем размер данных
-            ret = true;
-        }
-        lastActivityTime = millis();
+void EthernetMaketClient::disconnect() {
+    if (_sock != MAX_SOCK_NUM) {
+        ::disconnect(_sock);
     }
-    if(ret){
+}
+
+void EthernetMaketClient::close() {
+    if (_sock != MAX_SOCK_NUM) {
+        ::close(_sock);
+        _sock = MAX_SOCK_NUM;
+    }
+}
+
+void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonBlock) {
+    dstIP = ip;
+    dstPort = port;
+    isNonBlocking = nonBlock;
+    connectStatus = CONNECT_START;
+    startConnectionTime = millis();
+}
+
+bool EthernetMaketClient::dataWrite() {
+    if (!canWriteIntoConnection(dataSize)) return false;
+
+    if (write(dataPtr, dataSize)) {
+        clearData();
+        lastActivityTime = millis();
         onSendSuccess();
+        return true;
     }
-    return ret;
+
+    return false;
 }
 
 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()){
-            dataWrite();
-        }
+        activityUpdate();
     } else {
         Serial.println("Data buffer is not empty. Write operation is ignored.");
     }
 }
 
+void EthernetMaketClient::clearData() {
+    this->dataPtr = nullptr;
+    this->dataSize = 0;
+}
 
-// bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) {
-//     this->dataPtr = data;
-//     this->dataSize = dataSize;
-//     dstIP = ip;
-//     dstPort = port;
+bool EthernetMaketClient::isDataEmpty() const {
+    return this->dataPtr == nullptr;
+}
 
-//     switch (connectStatus) {
-//         case CONNECT_CONNECTED:
-//             if(dataWrite()){
-//                 onSendSuccess();
-//             }
-//             // Если подключено, отправляем данные
-//             return true;
+bool EthernetMaketClient::canWriteIntoConnection(size_t size) const {
+    return (connectStatus == CONNECT_CONNECTED) && (w5500.getTXFreeSize(_sock) >= size);
+}
 
-//         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::tick() {
+    forEach([](EthernetMaketClient &client) {
+        client.tick_();
+    });
+}
 
 void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
     onSendSuccess = callback;
@@ -288,44 +200,14 @@ void EthernetMaketClient::resetOnSendSuccess() {
     onSendSuccess = []() {};
 }
 
-void EthernetMaketClient::stop(){
+void EthernetMaketClient::stop() {
     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(); 
+ConnectionStatusSimple EthernetMaketClient::getConnectionStatus() const {
+    return connectStatus;
 }
 
-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;
-    
-    // Отключаем исполнение старого клиента
-    const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE;
-
-    return *this;
+void EthernetMaketClient::activityUpdate() {
+    lastActivityTime = millis();
 }
-

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,3 @@
-[] Проверить и отладить UDP
+[] Проверить и отладить UDP
+[] 8 статических клиентов для управления таймингами и сессией
+