DashyFox/Ethernet_W5500
1
0
Fork 0
mirror of https://github.com/Show-maket/EthernetMaket.git synced 2025-05-04 07:10:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: DashyFox:daf17f1ac686786e811ff3882baf532d70431655
Branches Tags
DashyFox:main
DashyFox:neuroFix-stateMashine
DashyFox:vanilla-server
DashyFox:todo-ReworkStateMachine
...
compare: DashyFox:71176f927473a4e544d026c7e8fb5007a6f05433
Branches Tags
DashyFox:neuroFix-stateMashine
DashyFox:vanilla-server
DashyFox:main
DashyFox:todo-ReworkStateMachine

4 Commits
daf17f1ac6 ... 71176f9274

Author SHA1 Message Date
DashyFox
71176f9274
Merge pull request #1 from Show-maket/vanilla-server 
vanilla
 2024-12-09 15:52:23 +03:00
DashyFox
9934fda584 vanilla 2024-12-09 15:36:16 +03:00
DashyFox
89c91cb68f d 2024-12-09 15:06:46 +03:00
DashyFox
a95cc42233 upd 2024-12-09 14:57:43 +03:00
4 changed files with 113 additions and 141 deletions
Show Stats Expand all files Collapse all files

173
src/EthernetOverride/Server.cpp
View File

@ -12,105 +12,124 @@ 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())
{ // {
client.stop(); // Serial.println("HARD STOP");
} // client.stop();
} // }
// }
if (!listening) // if (!listening)
{ // {
// begin(); // // begin();
begin(sock); // added // 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() void EthernetMaketServer::tick()
{ {
// for (int sock = 0; sock < MAX_SOCK_NUM; sock++) // for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
{ {
EthernetMaketClient sclient = available(serverSocket); EthernetClient sclient = available(/* serverSocket */);
if (sclient.connected() && sclient.available() > 0) 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(sclient);
} }
// // Закрытие соединения по таймеру неактивности
// if (sclient.connected() && (millis() - lastActivityTime > timeout))
// {
// Serial.println("Connection closed due to inactivity");
// sclient.stop();
// }
// if (!wasConnected && sclient.connected()) // if (!wasConnected && sclient.connected())
// { // {
// wasConnected[sock] = true; // wasConnected = true;
// Serial.println("Client connected");
// } // }
// if (wasConnected && !sclient.connected()) // if (wasConnected && !sclient.connected())
// { // {
// wasConnected[sock] = false; // wasConnected = false;
// sclient.stop(); // sclient.stop();
// // begin(serverSocket);
// Serial.println("Client disconnected"); // Serial.println("Client disconnected");
// } // }
// // Закрытие соединения по таймеру неактивности
// if (sclient.connected() && (millis() - lastActivityTime > timeout))
// {
// Serial.println("Connection closed due to inactivity");
// sclient.close();
// // begin(serverSocket);
// }
} }
} // sclient.tick_();
}

14
src/EthernetOverride/Server.h
View File

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

52
src/EthernetOverride/TCP.cpp
View File

@ -62,6 +62,8 @@ ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16
_sock = i; _sock = i;
Serial.print("SOCK <- "); Serial.println(_sock); Serial.print("SOCK <- "); Serial.println(_sock);
break; break;
//todo if (s == SnSR::LISTEN){ выполнить приём и занять на время отправки сокет прослушивания }
} }
} }
@ -110,7 +112,7 @@ void EthernetMaketClient::tick_(){
Serial.print("tick_() sock = "); Serial.println(_sock); Serial.print("tick_() sock = "); Serial.println(_sock);
} }
//todo [] Пересмотреть стейт машину перевести на нативные статусы
switch (connectStatus) switch (connectStatus)
{ {
case CONNECT_START: case CONNECT_START:
@ -197,7 +199,7 @@ void EthernetMaketClient::tick_(){
Serial.println("CONNECT_STOP_START"); Serial.println("CONNECT_STOP_START");
dstIP = IPAddress(0,0,0,0); dstIP = IPAddress(0,0,0,0);
dstPort = 0; dstPort = 0;
disconnect(); disconnect();
stopStartTime = millis(); stopStartTime = millis();
connectStatus = CONNECT_STOP_WAITING; connectStatus = CONNECT_STOP_WAITING;
Serial.println("CONNECT_STOP_WAITING"); Serial.println("CONNECT_STOP_WAITING");
@ -249,7 +251,8 @@ void EthernetMaketClient::tick_(){
} }
//******************************************************** //********************************************************
// //? Проверка наличия доступных данных от сервера // //? [*] Проверка наличия доступных данных от сервера
// //? проверяется во вне
// if (available() > 0) // if (available() > 0)
// { // {
@ -297,37 +300,6 @@ void EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool overr
} }
} }
// bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) {
// this->dataPtr = data;
// this->dataSize = dataSize;
// dstIP = ip;
// dstPort = port;
// switch (connectStatus) {
// case CONNECT_CONNECTED:
// if(dataWrite()){
// onSendSuccess();
// }
// // Если подключено, отправляем данные
// return true;
// case CONNECT_STOP_WAITING:
// case CONNECT_STOP_START:
// return false; // Ожидаем завершения разрыва
// // case CONNECT_FAIL:
// case CONNECT_IDLE:
// connectNonBlock(ip, port);
// connectStatus = CONNECT_START; // Начинаем новое подключение
// return false; // Подключение инициировано
// default:
// return false; // Пока ждём подключения
// }
// return false;
// }
void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) { void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
onSendSuccess = callback; onSendSuccess = callback;
} }
@ -337,6 +309,7 @@ void EthernetMaketClient::resetOnSendSuccess() {
} }
void EthernetMaketClient::stop(){ void EthernetMaketClient::stop(){
// if(connectStatus!=CONNECT_STOP_WAITING)
connectStatus = CONNECT_STOP_START; connectStatus = CONNECT_STOP_START;
} }
@ -345,15 +318,6 @@ void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonB
dstPort = port; dstPort = port;
isNonBlocking = nonBlock; isNonBlocking = nonBlock;
connectStatus = CONNECT_START; connectStatus = CONNECT_START;
// if (nonBlock)
// {
// connectNonBlock(dstIP, dstPort);
// }
// else
// {
// (ConnectionStatusSimple)connect(dstIP, dstPort);
// }
}; };
void EthernetMaketClient::activityUpdate(){ void EthernetMaketClient::activityUpdate(){
@ -379,6 +343,8 @@ EthernetMaketClient& EthernetMaketClient::operator=(const EthernetMaketClient& o
this->dataPtr = other.dataPtr; this->dataPtr = other.dataPtr;
this->dataSize = other.dataSize; this->dataSize = other.dataSize;
this->onSendSuccess = other.onSendSuccess; this->onSendSuccess = other.onSendSuccess;
this->_sock = other._sock;
// Отключаем исполнение старого клиента // Отключаем исполнение старого клиента
const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE; const_cast<EthernetMaketClient&>(other).connectStatus = CONNECT_IDLE;

15
src/EthernetOverride/TCPSession.h
View File

@ -1,15 +0,0 @@
#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;
}