问题[сокет]

我正在构建一个项目，其中一部分是 ESP32 上的套接字服务器。抛出此错误的场景如下：一个字符串到达​​套接字，{CHON}该字符串被成功处理，ESP32 打开必要的继电器并响应CHON，之后 Guru Meditation Error: Core 1 panic'ed (InstrFetchProhibited) 为抛出并且 ESP32 重新启动。请告诉我如何处理这个错误。
代码如下所示：

#include <WiFi.h>
#include <Wire.h>
 
 // Определяем максимальное количество клиентов, которые могут подключиться к этому серверу (обычно не более 4)
#define MAX_SRV_CLIENTS 5

 // Следующие три определения являются определениями отладки
#define DebugBegin(baud_rate)    Serial.begin(baud_rate)
#define DebugPrintln(message)    Serial.println(message)
#define DebugPrint(message)      Serial.print(message)
#define DebugPrintf(message)     Serial.printf(message)

int firstRelay = 5;
int secondRelay = 14;
 
const char* ssid = "Keenetic-6370";
const char* password = "vxTuT5JT";
 
 // Создаем номер порта сервера 80
WiFiServer server(80);
 // Управление клиентами
WiFiClient serverClients[MAX_SRV_CLIENTS];

long pushtime = 0;
 
void setup()
{
  pinMode(firstRelay, OUTPUT);
  digitalWrite(firstRelay, HIGH);
  pinMode(secondRelay, OUTPUT);
  digitalWrite(secondRelay, HIGH);
  
  DebugBegin(115200);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  DebugPrint("\nConnecting to "); 
  DebugPrintln(ssid);
  uint8_t i = 0;
  while (WiFi.status() != WL_CONNECTED && i++ < 30)
  {
    DebugPrint("."); 
    delay(500);
  }
  if (i == 21) 
  {
    DebugPrint("Could not connect to"); 
    DebugPrintln(ssid);
    while (1) 
    {
      delay(500);
    }
  }

  server.begin();   // Запускаем сервер
  server.setNoDelay(true);    // Отключаем функцию объединения небольших пакетов, без задержки при отправке данных
 
  DebugPrint("Ready! Use 'telnet ");
  DebugPrint(WiFi.localIP());
  DebugPrintln(" 80' to connect");
  pushtime = millis();
}
 
void loop()
{
  uint8_t i;
  if (server.hasClient())   // Определяем, поступает ли новый клиентский запрос
  {
    for (i = 0; i < MAX_SRV_CLIENTS; i++)   // Освобождаем старого недействительного или отключенного клиента
    {
      if (!serverClients[i] || !serverClients[i].connected())
      {
        if (serverClients[i])
        {
          serverClients[i].stop();
        }
        serverClients[i] = server.available();    // Назначаем последнего клиента
        DebugPrint("New client: "); 
        DebugPrintln(i);
        break;
      }
    }
    if (i == MAX_SRV_CLIENTS)   // Когда максимальное количество подключений достигнуто, подключение необходимо отклонить
    {
      WiFiClient serverClient = server.available();
      serverClient.stop();
      DebugPrintln("Connection rejected ");
    }
  }
 
  for (i = 0; i < MAX_SRV_CLIENTS; i++)   // Обнаружение данных, отправленных клиентом
  {
    if (serverClients[i] && serverClients[i].connected()) {
      if (serverClients[i].available())
      {
        String inString;
        while (serverClients[i].available())    //get data from the telnet client and push it to the UART
        {
          char inChar = serverClients[i].read();
          inString += inChar;
          delay(5);
          if (inChar == '}')
          {
            inString = "\n" + inString;
            if (inString.indexOf("{GLAVIARY}")>0)  // свет в навесе
            {
              digitalWrite(firstRelay, !digitalRead(firstRelay));
            }
            else if (inString.indexOf("{CHON}")>0)  // свет в домике куриц on
            {
              digitalWrite(secondRelay, LOW);
              for (i = 0; i < MAX_SRV_CLIENTS; i++)   // Отправляем данные каждому клиенту
              {
                if (serverClients[i] && serverClients[i].connected())
                {
                  serverClients[i].println("CHON");   // ПРЕДПОЛАГАЕМОЕ МЕСТО ОШИБКИ!!!
                  delay(5);
                }
              }
            }
            else
            {
              Serial.println("Wrong command");
            }
            inString = "";
          }
        }
      }
    }
  }
}

这是错误的样子：

在socket库中python有这样一个问题，数据检索函数的推荐值为recv4096字节。

我真的不明白这个值是如何证明的以及它来自哪里。关于此的文档非常谨慎地说：

注意：为了与硬件和网络现实进行最佳匹配，bufsize 的值应该是 2 的相对较小的幂，例如 4096。

而且看起来您应该深入研究硬件方面，但是例如MTU，以太网帧是1500字节，限制要TCP/UDP少一些2^16。

有一个很长的清单。如何保证将其发送到服务器并取回？我已经尝试过对数据进行切片）对于客户端，使用变量 var = 8000，不会完整返回列表...

服务器代码：

import socketserver

class ThredingTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass

class EchoTCPHandler(socketserver.BaseRequestHandler):

    def handle(self):
        def recvall(request):
            BUFF_SIZE = 4096  # 4 KiB
            data = b''
            while True:
                part = request.recv(BUFF_SIZE)
                data += part
                if len(part) < BUFF_SIZE:
                    break
            return data

        full_data = recvall(self.request)
        print(f'Adress: {self.client_address[0]}')
        print(f'Data: {len(full_data)} {full_data}')
        # некая операция
        #d = eval(full_data)
        #d = d[::-1]

        msg = str(full_data).encode()
        self.request.sendall(msg)

if __name__ == '__main__':
    with ThredingTCPServer(('', 8888), EchoTCPHandler) as server:
        server.serve_forever()

客户端代码：

import socket


def recvall(sock):
    BUFF_SIZE = 4096 # 4 KiB
    data = b''
    while True:
        part = sock.recv(BUFF_SIZE)
        data += part
        if len(part) < BUFF_SIZE:
            break
    return data


var = 8000
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 8888))
msg = str([i*i for i in range(var)]).encode()
sock.send(msg)
res = recvall(sock)
ans = res.decode()
print(len(ans), ans)
sock.close()

我玩socket。我有点想通了正常的版本，现在我想写一个异步的。例如一个简单的回显服务器。有一个代码：

    async def _run(self) -> None:
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.bind((settings.HOST, settings.PORT))
        self.server_socket.listen(8)
        self.server_socket.setblocking(False)

        loop = asyncio.get_event_loop()

        while True:
            client, address = await loop.sock_accept(self.server_socket)
            print(f"Connected {address}")
            loop.create_task(self.handle_client(client, address))

    async def handle_client(self, client_socket: socket.socket, address: tuple) -> None:
        while True:
            data = client_socket.recv(1024).decode(encoding=settings.ENCODING)  # BlockingIOError: [WinError 10035] Операция на незаблокированном сокете не может быть завершена немедленно
            if not data:
                break
            client_socket.send(data.upper().encode(encoding=settings.ENCODING))
            print(data)

它因错误而中断：

BlockingIOError: [WinError 10035] Операция на незаблокированном сокете не может быть завершена немедленно

我大致理解为什么：需要self.server_socket.setblocking(False)实现异步并且客户端还没有读取过去的数据或者根本还没有准备好。client_socket.recv如果你把before time.sleep，那么一切都开始工作，但这显然不是一个解决方案。

我怎样才能异步（以便在那一刻处理其他客户端）等待我可以读/写东西的那一刻？

PS我知道asyncore，但我想从头开始写一切，并从内部了解一切是如何运作的

我使用 tcp/ip 监视器从 localhost:8080 监视 eclipse 站点（作为示例，了解 tcp/ip 的工作原理）。我删除了这台显示器，但没有停止它。现在 localhost:8080 总是将我重定向到 Eclipse 站点。我试图打开一个相同的监视器并关闭它，在同一个套接字 8080 上打开监视器，但使用不同的主机名（当我输入 localhost:8080 时，它会将我重定向到 eclipse 网站，而不是新的主机名），断开连接从互联网（地址仍然更改为www.eclipse.org，但该站点当然不可用），删除 eclipse - 没有任何作用。我试图在主机名为www.eclipse.org的套接字 9000 上打开另一个监视器，启动、停止，现在这个套接字也卡在这个站点上，但我没有删除这个监视器。

如何解决？