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

ClientClass

Browse Source
This commit is contained in:
DashyFox 2024-11-20 15:22:33 +03:00
parent eee3b84b8e
commit 994ce2490f
3 changed files with 151 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
examples/Client/Client.ino
View File

@ -55,13 +55,13 @@ void setup()
} }
bool dataReady = false;
void loop() void loop()
{ {
EthernetMaketClient::tick(); EthernetMaketClient::tick();
uint32_t currentMillis = millis(); uint32_t currentMillis = millis();
if (currentMillis - ttt > 75) if (currentMillis - ttt > 25)
{ {
digitalToggle(PC13); digitalToggle(PC13);
ttt = currentMillis; // Обновляем время ttt = currentMillis; // Обновляем время
@ -71,13 +71,14 @@ void loop()
{ {
previousMillis = currentMillis; previousMillis = currentMillis;
// client.stop(); // Завершаем предыдущее соединение Serial.println("connectNonBlock");
// connectStatus = CONNECT_START; // функция коннекта client.connectNonBlock(serverIP, SERVER_PORT);
// client.connect(serverIP, SERVER_PORT); client.connectStatus = CONNECT_START;
// client.setData(buf, sizeof(buf));
// client()
if (client.connectNonBlock(serverIP, SERVER_PORT) == CONNECT_CONNECTED) dataReady = true;
}
if(dataReady && client.isConnected())
{ {
for (size_t i = 0; i < 3; i++) for (size_t i = 0; i < 3; i++)
{ {
@ -93,12 +94,6 @@ void loop()
Serial.println(); Serial.println();
packetCounter++; packetCounter++;
} }
} dataReady = false;
else
{
Serial.println("Failed to connect to server");
client.stop();
}
} }
} }

130
src/EthernetOverride/TCP.cpp
View File

@ -2,25 +2,27 @@
#include "utility/w5500.h" #include "utility/w5500.h"
#include "utility/socket.h" #include "utility/socket.h"
std::vector<EthernetMaketClient*> EthernetMaketClient::instances; std::list<EthernetMaketClient*>& EthernetMaketClient::getInstances() {
static std::list<EthernetMaketClient*> instances; // Список создаётся при первом доступе
return instances;
}
EthernetMaketClient::EthernetMaketClient() { EthernetMaketClient::EthernetMaketClient() {
_sock = MAX_SOCK_NUM; _sock = MAX_SOCK_NUM;
instances.push_back(this); getInstances().push_back(this);
} }
EthernetMaketClient::EthernetMaketClient(uint8_t sock) { EthernetMaketClient::EthernetMaketClient(uint8_t sock) {
_sock = sock; _sock = sock;
instances.push_back(this); getInstances().push_back(this);
} }
EthernetMaketClient::~EthernetMaketClient() { EthernetMaketClient::~EthernetMaketClient() {
instances.erase(std::remove(instances.begin(), instances.end(), this), instances.end()); getInstances().remove(this);
} }
void EthernetMaketClient::tick() { void EthernetMaketClient::tick() {
for (EthernetMaketClient* client : instances) { for (EthernetMaketClient* client : getInstances()) {
client->tick_(); client->tick_();
} }
} }
@ -28,26 +30,30 @@ void EthernetMaketClient::tick() {
ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16_t port) { ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16_t port) {
dstIP = ip; dstIP = ip;
dstPort = port; dstPort = port;
// if(connectStatus == CONNECT_IDLE){
// connectStatus = CONNECT_START;
// }
if (_sock != MAX_SOCK_NUM) { if (_sock != MAX_SOCK_NUM) {
// Serial.println(F("connectNonBlock"));
uint8_t status_ = status(); uint8_t status_ = status();
switch (status_) { switch (status_) {
case SnSR::CLOSED: case SnSR::CLOSED:
// Serial.println(F("CLOSED")); Serial.println(F("connectNonBlock(): CONNECT_FAIL (CLOSED)"));
_sock = MAX_SOCK_NUM; _sock = MAX_SOCK_NUM;
return CONNECT_FAIL; return CONNECT_FAIL;
break; break;
case SnSR::ESTABLISHED: case SnSR::ESTABLISHED:
// Serial.println(F("ESTABLISHED")); Serial.println(F("connectNonBlock(): CONNECT_SUCCESS (ESTABLISHED)"));
return CONNECT_SUCCESS; return CONNECT_SUCCESS;
break; break;
default: default:
// Serial.print(F("status ")); Serial.println(F("connectNonBlock(): CONNECT_CONNECTING (Default)"));
// Serial.println(status_,HEX);
return CONNECT_CONNECTING; return CONNECT_CONNECTING;
break; break;
} }
} }
for (int i = 0; i < MAX_SOCK_NUM; i++) { for (int i = 0; i < MAX_SOCK_NUM; i++) {
uint8_t s = w5500.readSnSR(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::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
@ -56,21 +62,29 @@ ConnectionStatusSimple EthernetMaketClient::connectNonBlock(IPAddress ip, uint16
} }
} }
if (_sock == MAX_SOCK_NUM) if (_sock == MAX_SOCK_NUM) {
Serial.println(F("connectNonBlock(): CONNECT_FAIL (No available socket)"));
return CONNECT_FAIL; return CONNECT_FAIL;
}
Serial.print("sock: ");
Serial.println(_sock);
_srcport++; _srcport++;
if (_srcport == 0) _srcport = 1024; if (_srcport == 0) _srcport = 1024;
socket(_sock, SnMR::TCP, _srcport, 0); socket(_sock, SnMR::TCP, _srcport, 0);
if (!::connect(_sock, rawIPAddress(ip), port)) { if (!::connect(_sock, rawIPAddress(ip), port)) {
Serial.println(F("connectNonBlock(): CONNECT_FAIL (Connect failed)"));
_sock = MAX_SOCK_NUM; _sock = MAX_SOCK_NUM;
return CONNECT_FAIL; return CONNECT_FAIL;
} }
Serial.println(F("connectNonBlock(): CONNECT_CONNECTING (Connection initiated)"));
return CONNECT_CONNECTING; return CONNECT_CONNECTING;
} }
bool EthernetMaketClient::isConnected() const { bool EthernetMaketClient::isConnected() const {
return connectStatus == CONNECT_CONNECTED; return connectStatus == CONNECT_CONNECTED;
} }
@ -89,28 +103,31 @@ void EthernetMaketClient::close(){
} }
void EthernetMaketClient::tick_(){ void EthernetMaketClient::tick_(){
// Подключаемся к серверу
switch (connectStatus) switch (connectStatus)
{ {
case CONNECT_START: case CONNECT_START:
startConnection = millis(); Serial.println("CONNECT_START");
startConnectionTime = millis();
connectStatus = CONNECT_CONNECTING; connectStatus = CONNECT_CONNECTING;
close(); close();
Serial.println("\n\nConnecting..."); Serial.println("CONNECT_CONNECTING...");
break; break;
case CONNECT_CONNECTING: case CONNECT_CONNECTING:
if (millis() - startConnection >= connectionTimeout) if (millis() - startConnectionTime >= connectionTimeout)
{ {
connectStatus = CONNECT_FAIL; connectStatus = CONNECT_FAIL;
break; break;
} }
break; break;
case CONNECT_FAIL: case CONNECT_FAIL:
Serial.println("CONNECT_FAIL");
Serial.print("Failed to connect to server in "); Serial.print("Failed to connect to server in ");
Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode"); Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode");
Serial.println("\n");
connectStatus = CONNECT_STOP_START; connectStatus = CONNECT_STOP_START;
break; break;
case CONNECT_SUCCESS: case CONNECT_SUCCESS:
Serial.println("CONNECT_SUCCESS");
Serial.print("Connected to server in "); Serial.print("Connected to server in ");
Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode"); Serial.println(isNonBlocking ? "non-blocking mode" : "blocking mode");
lastActivityTime = millis(); lastActivityTime = millis();
@ -140,6 +157,7 @@ void EthernetMaketClient::tick_(){
break; break;
case CONNECT_STOP_START: case 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();
@ -148,23 +166,27 @@ void EthernetMaketClient::tick_(){
break; break;
case CONNECT_STOP_WAITING: case CONNECT_STOP_WAITING:
Serial.println("CONNECT_STOP_WAITING");
if (millis() - stopStartTime >= stopTimeout) { if (millis() - stopStartTime >= stopTimeout) {
close(); // Окончательное закрытие сокета после таймаута close(); // Окончательное закрытие сокета после таймаута
connectStatus = (dataSize > 0) ? CONNECT_START : CONNECT_IDLE; connectStatus = CONNECT_IDLE;
} else { } else {
// Проверяем состояние сокета для завершения разрыва // Проверяем состояние сокета для завершения разрыва
uint8_t status_ = status(); uint8_t status_ = status();
if (status_ == SnSR::CLOSED || status_ == SnSR::CLOSE_WAIT) { if (status_ == SnSR::CLOSED || status_ == SnSR::CLOSE_WAIT) {
close(); // Закрываем при достижении состояния close(); // Закрываем при достижении состояния
connectStatus = (dataSize > 0) ? CONNECT_START : CONNECT_IDLE; connectStatus = CONNECT_IDLE;
} }
} }
if(connectStatus == CONNECT_IDLE) {
Serial.println("CONNECT_IDLE\n\n");
}
break; break;
case CONNECT_IDLE: case CONNECT_IDLE:
if(dataSize){ // if(dataSize){
connectStatus = CONNECT_START; // connectStatus = CONNECT_START;
} // }
break; break;
default: default:
@ -175,9 +197,6 @@ void EthernetMaketClient::tick_(){
{ {
case CONNECT_START: case CONNECT_START:
case CONNECT_CONNECTING: case CONNECT_CONNECTING:
if(dstIP == IPAddress(0,0,0,0) || dstPort == 0)
break;
if (isNonBlocking) if (isNonBlocking)
{ {
connectStatus = connectNonBlock(dstIP, dstPort); connectStatus = connectNonBlock(dstIP, dstPort);
@ -237,7 +256,7 @@ bool EthernetMaketClient::dataWrite(){
bool ret = false; bool ret = false;
if(dataSize) { if(dataSize) {
lastActivityTime = millis(); lastActivityTime = millis();
if(write((uint8_t *)&dataPtr, dataSize)){ if(write(dataPtr, dataSize)){
dataPtr = nullptr; dataPtr = nullptr;
dataSize = 0; // Очищаем размер данных dataSize = 0; // Очищаем размер данных
ret = true; ret = true;
@ -248,7 +267,7 @@ bool EthernetMaketClient::dataWrite(){
} }
bool EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool override) { bool EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool override) {
if (dataSize == 0 || override || (dataPtr == nullptr && this->dataSize == 0)) { if (this->dataSize == 0 || override) {
this->dataPtr = data; this->dataPtr = data;
this->dataSize = dataSize; this->dataSize = dataSize;
return dataWrite(); return dataWrite();
@ -259,32 +278,35 @@ bool EthernetMaketClient::dataWrite(uint8_t* data, uint16_t dataSize, bool overr
} }
bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) { // bool EthernetMaketClient::send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port) {
this->dataPtr = data; // this->dataPtr = data;
this->dataSize = dataSize; // this->dataSize = dataSize;
// dstIP = ip;
// dstPort = port;
switch (connectStatus) { // switch (connectStatus) {
case CONNECT_CONNECTED: // case CONNECT_CONNECTED:
if(dataWrite()){ // if(dataWrite()){
onSendSuccess(); // onSendSuccess();
} // }
// Если подключено, отправляем данные // // Если подключено, отправляем данные
return true; // return true;
case CONNECT_STOP_WAITING: // case CONNECT_STOP_WAITING:
case CONNECT_STOP_START: // case CONNECT_STOP_START:
return false; // Ожидаем завершения разрыва // return false; // Ожидаем завершения разрыва
case CONNECT_FAIL: // // case CONNECT_FAIL:
case CONNECT_IDLE: // case CONNECT_IDLE:
connectNonBlock(ip, port); // connectNonBlock(ip, port);
connectStatus = CONNECT_START; // Начинаем новое подключение // connectStatus = CONNECT_START; // Начинаем новое подключение
return false; // Подключение инициировано // return false; // Подключение инициировано
default: // default:
return false; // Пока ждём подключения // return false; // Пока ждём подключения
} // }
} // return false;
// }
void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) { void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback) {
onSendSuccess = callback; onSendSuccess = callback;
@ -293,3 +315,15 @@ void EthernetMaketClient::setOnSendSuccess(const std::function<void()>& callback
void EthernetMaketClient::resetOnSendSuccess() { void EthernetMaketClient::resetOnSendSuccess() {
onSendSuccess = []() {}; onSendSuccess = []() {};
} }
void EthernetMaketClient::stop(){
connectStatus = CONNECT_STOP_START;
}
void EthernetMaketClient::startConnection(IPAddress ip, uint16_t port, bool nonBlock){
dstIP = ip;
dstPort = port;
isNonBlocking = nonBlock;
connectNonBlock(dstIP, dstPort);
connectStatus = CONNECT_START;
};

25
src/EthernetOverride/TCP.h
View File

@ -1,7 +1,7 @@
#ifndef __MAKET_TCP_H__ #ifndef __MAKET_TCP_H__
#define __MAKET_TCP_H__ #define __MAKET_TCP_H__
#include <vector> #include <list>
#include <functional> #include <functional>
#include "../util/config.h" #include "../util/config.h"
@ -9,7 +9,7 @@ class EthernetMaketClient : public EthernetClient {
protected: protected:
uint32_t lastActivityTime = 0; // Время последней активности uint32_t lastActivityTime = 0; // Время последней активности
const uint16_t timeout = 300; // Таймаут неактивности в миллисекундах const uint16_t timeout = 300; // Таймаут неактивности в миллисекундах
uint32_t startConnection = 0; uint32_t startConnectionTime = 0;
const uint16_t connectionTimeout = 350; const uint16_t connectionTimeout = 350;
uint32_t stopStartTime = 0; // Время начала состояния CONNECT_IDLE uint32_t stopStartTime = 0; // Время начала состояния CONNECT_IDLE
const uint32_t stopTimeout = 300; // Таймаут для закрытия сокета в состоянии CONNECT_IDLE const uint32_t stopTimeout = 300; // Таймаут для закрытия сокета в состоянии CONNECT_IDLE
@ -17,32 +17,39 @@ protected:
std::function<void()> onSendSuccess = []() {}; std::function<void()> onSendSuccess = []() {};
bool isNonBlocking = true; // Флаг для определения режима подключения bool isNonBlocking = true; // Флаг для определения режима подключения
ConnectionStatusSimple connectStatus = CONNECT_IDLE;
uint8_t* dataPtr; uint8_t* dataPtr = nullptr;
uint16_t dataSize = 0; uint16_t dataSize = 0;
IPAddress dstIP; IPAddress dstIP;
uint16_t dstPort; uint16_t dstPort;
bool dataWrite(); bool dataWrite();
static std::vector<EthernetMaketClient*> instances; static std::list<EthernetMaketClient*>& getInstances(); // Ленивое создание списка
void tick_(); void tick_();
public: public:
ConnectionStatusSimple connectStatus = CONNECT_IDLE;
EthernetMaketClient(); EthernetMaketClient();
EthernetMaketClient(uint8_t sock); EthernetMaketClient(uint8_t sock);
~EthernetMaketClient(); ~EthernetMaketClient();
ConnectionStatusSimple connectNonBlock(IPAddress ip, uint16_t port); ConnectionStatusSimple connectNonBlock(IPAddress ip, uint16_t port);
void startConnection(IPAddress ip, uint16_t port, bool nonBlock = true);
bool dataWrite(uint8_t* data, uint16_t dataSize, bool override = false);
// bool send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port);
void disconnect(); void disconnect();
void close(); void close();
void stop();
bool isConnected() const;
static void tick(); static void tick();
bool send(uint8_t* data, uint16_t dataSize, IPAddress ip, uint16_t port);
bool isConnected() const;
void setOnSendSuccess(const std::function<void()>& callback); void setOnSendSuccess(const std::function<void()>& callback);
void resetOnSendSuccess(); void resetOnSendSuccess();
bool dataWrite(uint8_t* data, uint16_t dataSize, bool override = false);
}; };
#endif // __MAKET_TCP_H__ #endif // __MAKET_TCP_H__