server.py

# import socket
# import asyncio
#
# class P2Peer:
#     def __init__(self, host='localhost', port=12345):
#         self.host = host
#         self.port = port
#         self.server_socket = None
#         self.PACKET_SIZE = 35  # 0xAA 0xBB 8*float(4) + 8*bool(1/8) = 35字节
#         self.DATA_SIZE = 33
#         self.PACKET_HEADER = b'\xAA\xBB'  # 2字节包头
#         self.buffer = b''
#
#     def start(self):
#         self.running_loop = asyncio.get_event_loop()
#         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#         self.sock.bind((self.host, self.port))
#
#         print(f"Peer started at {self.host}:{self.port}")
#
#         asyncio.create_task(self.receiveLoop())  # 注册接收事件
#
#     async def receiveLoop(self):
#         while True:
#             data, addr = await self.running_loop.sock_recvfrom(self.sock, 1024)  # 注册事件
#             print(f"Received message: {data.decode()} from {addr}")
#
#     # async def consumeOneMessage(self):
#     #     while True:
#     #         header_index = self.buffer.find(self.PACKET_HEADER)
#     #         if header_index != -1:
#     #             # 如果没有找到包头，等待更多数据
#     #             message_end_index = header_index + self.DATA_SIZE + len(self.PACKET_HEADER)
#     #
#     #             continue
#     async def readOneMessage()
#
#     def parse_message(self, message):
#
#         return message

import asyncio
import struct
import Serial
from typing import cast

class UDPProtocol(asyncio.DatagramProtocol):
    def __init__(self, server):
        self.server = server
        self.PACKET_SIZE = 35
        self.DATA_SIZE = 33
        self.PACKET_HEADER = b"\xaa\xbb"  # 2字节包头

        self.serial_protocol = None

    def connection_made(self, transport):
        self.transport = transport
        print(f"Server started on {self.server.host}:{self.server.port}")

    def datagram_received(self, data, addr):
        print(f"Received data from {addr}")
        # floats, bools = self.__parse(data)
        # Serial.serial_protocol.schedule_send(data)
        if self.serial_protocol:
            self.serial_protocol.schedule_send(data)

    def error_received(self, exc):
        print(f"Error received: {exc}")

    def __parse(self, data):
        if len(data) != self.PACKET_SIZE:
            print(f"Invalid packet size: {len(data)}")

        floats = struct.unpack(">8f", data[: self.DATA_SIZE - 1])
        bools = []
        for i in range(8):
            bit_value = data[self.DATA_SIZE - 1] & (1 << i)
            bools.append(bool(bit_value))

        return floats, bools

    def schedule_send(self, message):
        def send():
            self.transport.sendto(message)
        self.server.loop.call_soon(send)

class Server:
    def __init__(self, host="localhost", port=12345):
        self.host = host
        self.port = port
        self.server_socket = None
        self.loop = asyncio.get_event_loop()
        self.serial_protocol = None

    async def run(self):
        self.transport, self.protocol = await self.loop.create_datagram_endpoint(
            lambda: UDPProtocol(self),
            local_addr=(self.host, self.port),
        )
        self.transport = cast(asyncio.DatagramTransport, self.transport)
        print(f"Server running on {self.host}:{self.port}")
        return self.transport, self.protocol



async def initAll():
    serial_transport, serial_protocol = await Serial.initSerial()
    server_transport, server_protocol = await Server().run()

    server_protocol.serial_protocol = serial_protocol
    serial_protocol.server_protocol = server_protocol

    

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.create_task(initAll())
    loop.run_forever()