testing

src/EthernetOverride/Server.cpp

@@ -9,120 +9,106 @@ void EthernetMaketServer::setServerHandler(std::function<void(EthernetMaketClien
 
 void EthernetMaketServer::resetServerHandler()
 {
-    serverHandler = [](EthernetMaketClient sclient) {};
+    serverHandler = [](EthernetMaketClient &sclient) {};
 }
 
-// EthernetMaketClient EthernetMaketServer::available(int sock)
+EthernetMaketClient EthernetMaketServer::available(int sock)
-// {
+{
-//     accept(sock);
+    accept(sock);
-//     EthernetClient client(sock);
+    EthernetClient client(sock);
-//     if (EthernetClass::_server_port[sock] == _port &&
+    if (EthernetClass::_server_port[sock] == _port &&
-//         (client.status() == SnSR::ESTABLISHED ||
+        (client.status() == SnSR::ESTABLISHED ||
-//          client.status() == SnSR::CLOSE_WAIT))
+         client.status() == SnSR::CLOSE_WAIT))
-//     {
+    {
-//         if (client.available())
+        if (client.available())
-//         {
+        {
-//             return std::move(EthernetMaketClient(client));
+            return std::move(EthernetMaketClient(client));
-//         }
+        }
-//     }
+    }
-//     return std::move(EthernetMaketClient(MAX_SOCK_NUM));
+    return std::move(EthernetMaketClient(MAX_SOCK_NUM));
-// }
+}
 
-// void EthernetMaketServer::accept(int sock)
+void EthernetMaketServer::accept(int sock)
-// {
+{
-//     int listening = 0;
+    int listening = 0;
-//     EthernetClient client(sock);
+    EthernetClient client(sock);
 
-//     if (EthernetClass::_server_port[sock] == _port)
+    if (EthernetClass::_server_port[sock] == _port)
-//     {
+    {
-//         if (client.status() == SnSR::LISTEN)
+        if (client.status() == SnSR::LISTEN)
-//         {
+        {
-//             listening = 1;
+            listening = 1;
-//         }
+        }
-//         else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
+        else if (client.status() == SnSR::CLOSE_WAIT && !client.available())
-//         {
+        {
-//             Serial.println("HARD STOP");
+            Serial.println("HARD STOP");
-//             client.stop();
+            client.stop();
-//         }
+        }
-//     }
+    }
 
-//     if (!listening)
+    if (!listening)
-//     {
+    {
-//         // begin();
+        begin();
         // begin(sock); // added
-//     }
+    }
-// }
+}
 
-// void EthernetMaketServer::begin(int sock)
+void EthernetMaketServer::begin(int sock)
-// {
+{
-//     EthernetClient client(sock);
+    EthernetClient client(sock);
-//     if (client.status() == SnSR::CLOSED)
+    if (client.status() == SnSR::CLOSED)
-//     {
+    {
-//         socket(sock, SnMR::TCP, _port, 0);
+        socket(sock, SnMR::TCP, _port, 0);
-//         listen(sock);
+        listen(sock);
-//         EthernetClass::_server_port[sock] = _port;
+        EthernetClass::_server_port[sock] = _port;
-//         serverSocket = sock; 
+        serverSocket = sock; 
-//         return;
+        return;
-//     } 
+    } 
-//     // Serial.println(F("EthernetMaketServer::begin() FAIL"));
+    // 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"));
+}
 
-// 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 */);
+        sclient = available(serverSocket);
-        size_t dataSize;
+        if (sclient.connected() && sclient.available() > 0)
-        if (sclient.connected() && (dataSize = sclient.available()) > 0)
         {
-            // Serial.println("Receive!");
+            sclient.activityUpdate();
-
+            serverHandler(sclient);
-            // 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())
+        if (!wasConnected && sclient.connected())
-        // {
+        {
-        //     wasConnected = true;
+            wasConnected = true;
-        //     Serial.println("Client connected");
+            Serial.println("Client connected");
-        // }
+        }
 
-        // if (wasConnected && !sclient.connected())
+        if (wasConnected && !sclient.connected())
-        // {
+        {
-        //     wasConnected = false;
+            wasConnected = false;
-        //     sclient.stop();
+            sclient.stop();
-        //     // begin(serverSocket);
+            // begin(serverSocket);
-        //     Serial.println("Client disconnected");
+            Serial.println("Client disconnected");
-        // }
+        }
         // // Закрытие соединения по таймеру неактивности
         // if (sclient.connected() && (millis() - lastActivityTime > timeout))
         // {
@@ -131,5 +117,5 @@ void EthernetMaketServer::tick()
         //     // begin(serverSocket);
         // }
     }
-    // sclient.tick_();
+    sclient.tick_();
 }

src/EthernetOverride/Server.h

@@ -8,22 +8,22 @@ class EthernetMaketClient;
 class EthernetMaketServer : public EthernetServer
 {
 private:
-    // EthernetClient available();
+    EthernetClient available();
-    // void accept(int sock);
+    void accept(int sock);
-    std::function<void(EthernetMaketClient)> serverHandler = [](EthernetMaketClient sclient) {};
+    std::function<void(EthernetMaketClient&)> serverHandler = [](EthernetMaketClient &sclient) {};
     SOCKET serverSocket = MAX_SOCK_NUM;
 
     bool wasConnected;
-    // EthernetMaketClient sclient;
+    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() override;
-    // void begin(int sock);
+    void begin(int sock);
     void tick();
 };
 

src/EthernetOverride/TCP.cpp

@@ -2,165 +2,286 @@
 #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();
 }
 
-EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& other) {
+void EthernetMaketClient::tick()
-    if (this == &other) {
+  {
-        return *this; // Защита от самоприсваивания
+    forEach(
+        [](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::ESTABLISHED:
-                connectStatus = CONNECT_SUCCESS;
-                return CONNECT_SUCCESS;
             case SnSR::CLOSED:
-            case SnSR::CLOSE_WAIT:
+                Serial.println(F("connectNonBlock(): CONNECT_FAIL (CLOSED)"));
-                close(); // Освобождаем сокет перед попыткой нового подключения
+                _sock = MAX_SOCK_NUM;
+                return CONNECT_FAIL;
+                break;
+            case SnSR::ESTABLISHED:
+                Serial.println(F("connectNonBlock(): CONNECT_SUCCESS (ESTABLISHED)"));
+                return CONNECT_SUCCESS;
                 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::CLOSE_WAIT) {
+        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){ выполнить приём и занять на время отправки сокет прослушивания }
         }
     }
 
     if (_sock == MAX_SOCK_NUM) {
-        connectStatus = CONNECT_FAIL;
+        Serial.println(F("connectNonBlock(): CONNECT_FAIL (No available socket)"));
         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;
     }
 
-    connectStatus = CONNECT_CONNECTING;
+    Serial.println(F("connectNonBlock(): CONNECT_CONNECTING (Connection initiated)"));
     return CONNECT_CONNECTING;
 }
 
-void EthernetMaketClient::tick_() {
-    if (_sock == MAX_SOCK_NUM) {
-        connectStatus = CONNECT_IDLE;
-        return;
-    }
 
-    uint8_t s = w5500.readSnSR(_sock);
+bool EthernetMaketClient::canWriteIntoConnection(size_t size) const {
-
+    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){
+        Serial.print("tick_() sock = "); Serial.println(_sock); 
     }
 
-void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonBlock) {
+//todo [] Пересмотреть стейт машину перевести на нативные статусы
-    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;
+        }
+        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(){
-    if (!canWriteIntoConnection(dataSize)) return false;
+    bool ret = false;
-
+    if(dataSize) {
+        lastActivityTime = millis();
         if(write(dataPtr, dataSize)){
             clearData();
+            ret = true;
+        }
         lastActivityTime = millis();
+    }
+    if(ret){
         onSendSuccess();
-        return true;
+    }
+    return ret;
 }
 
-    return false;
+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) {
@@ -168,30 +289,17 @@ 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;
 }
@@ -201,13 +309,49 @@ 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();
-}