upd

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-байтового пакета
+    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);
+    // // Обработка каждого 4-байтового пакета
-        for (uint8_t j = 0; j < 3; j++)
+    // for (int i = 0; i < len; i += 4)
-        {
+    // {
-            sendResponse(client, *(uint32_t *)(buf + i));
+    //     int packetLen = min(4, len - i); // Определяем длину текущего пакета
-        }
+    //     processReceivedData(buf + i, packetLen);
-        packetCounter++;
+    //     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

@@ -9,23 +9,23 @@ void EthernetMaketServer::setServerHandler(std::function<void(EthernetMaketClien
 
 void EthernetMaketServer::resetServerHandler()
 {
-    serverHandler = [](EthernetMaketClient sclient) {};
+    serverHandler = [](EthernetMaketClient &sclient) {};
 }
 
 EthernetMaketClient EthernetMaketServer::available(int sock)
 {
     accept(sock);
-    EthernetMaketClient client(sock);
+    EthernetClient client(sock);
     if (EthernetClass::_server_port[sock] == _port &&
         (client.status() == SnSR::ESTABLISHED ||
          client.status() == SnSR::CLOSE_WAIT))
     {
         if (client.available())
         {
-            return client;
+            return std::move(EthernetMaketClient(client));
         }
     }
-    return EthernetMaketClient(MAX_SOCK_NUM);
+    return std::move(EthernetMaketClient(MAX_SOCK_NUM));
 }
 
 void EthernetMaketServer::accept(int sock)
@@ -60,23 +60,40 @@ void EthernetMaketServer::begin(int sock)
         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()
 {
-    EthernetServer::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"));
 }
 
 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);
+        EthernetMaketClient sclient = available(serverSocket);
         if (sclient.connected() && sclient.available() > 0)
         {
             serverHandler(sclient);
         }
+
+
+
+
         // // Закрытие соединения по таймеру неактивности
         // if (sclient.connected() && (millis() - lastActivityTime > timeout))
         // {

src/EthernetOverride/Server.h

@@ -10,8 +10,9 @@ class EthernetMaketServer : public EthernetServer
 private:
     EthernetClient available();
     void accept(int sock);
-    std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
+    std::function<void(EthernetMaketClient&)> serverHandler = [](EthernetMaketClient &sclient) {};
     bool wasConnected[MAX_SOCK_NUM];
+    SOCKET serverSocket = MAX_SOCK_NUM;
 
 public:
     using EthernetServer::EthernetServer;

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) {  
+            obj.tick_();
+        }
+    );
 
-void EthernetMaketClient::tick() {
+  }
-    for (EthernetMaketClient* client : getInstances()) {
+
-        client->tick_();
+////////////////////////////////////////////////////////////////
-    }
-}
 
 ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16_t port) {
     dstIP = ip;
@@ -58,6 +60,7 @@ 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;
         }
     }
@@ -85,8 +88,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 +106,11 @@ void EthernetMaketClient::close(){
 }
 
 void EthernetMaketClient::tick_(){
+    if(_sock != MAX_SOCK_NUM && connectStatus!=CONNECT_CONNECTED && connectStatus!=CONNECT_STOP_WAITING&&connectStatus!=CONNECT_CONNECTING){
+        Serial.print("tick_() sock = "); Serial.println(_sock); 
+    }
+
+
     switch (connectStatus)
     {
     case CONNECT_START:
@@ -111,6 +119,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)
@@ -225,8 +262,7 @@ bool EthernetMaketClient::dataWrite(){
     if(dataSize) {
         lastActivityTime = millis();
         if(write(dataPtr, dataSize)){
-            dataPtr = nullptr; 
+            clearData();
-            dataSize = 0; // Очищаем размер данных
             ret = true;
         }
         lastActivityTime = millis();
@@ -237,13 +273,25 @@ 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.");
     }
@@ -297,6 +345,15 @@ void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonB
         dstPort = port;
         isNonBlocking = nonBlock;
         connectStatus = CONNECT_START;
+        // if (nonBlock)
+        // {
+        //     connectNonBlock(dstIP, dstPort);
+        // }
+        // else
+        // {
+        //     (ConnectionStatusSimple)connect(dstIP, dstPort);
+        // }
+
 };
 
 void EthernetMaketClient::activityUpdate(){
@@ -329,3 +386,6 @@ EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& o
     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();
 };
 

src/EthernetOverride/TCPSession.h

@@ -0,0 +1,15 @@
+#include "TCP.h"
+
+static EthernetMaketClient tcpSock[MAX_SOCK_NUM];
+
+using TCP_SESSION = SOCKET;
+
+TCP_SESSION newConnection(IPAddress ip, uint16_t port, bool nonBlock = true){
+    for(int i = 0; i < MAX_SOCK_NUM; i++){
+        if(tcpSock[i].status() == SnSR::CLOSED){
+            tcpSock[i].startConnection(ip, port, nonBlock);
+            return i;
+        }
+    }
+    return MAX_SOCK_NUM;
+}

todo

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