Serial.py

from serial.tools import list_ports
from typing import cast

import json
import struct
import enum
import asyncio
import serial_asyncio
import logging

# class Serial:
#     def __init__(self, loop, port, baudrate=115200):
#         self.loop = loop
#         # 初始化串口
#         self.reader, self.writer = await serial_asyncio.open_serial_connection(
#             url=port, baudrate=baudrate, bytesize=8, parity="N", stopbits=1
#         )
#
#         self.ser.flush()
#         self.rxstate = 0  # 接收状态机的初始状态
#         self.rx_id = 0  # 接收到的 ID
#         self.rx_map = {  # 由类型组成的字典
#             Data.DEPTH: [float],  # 深度
#             Data.ATTITUDE: [float, float, float],  # Roll, Pitch, Yaw
#             Data.JOYSTICK: [
#                 float,
#                 float,
#                 float,
#                 float,
#                 float,
#                 float,
#                 float,
#                 float,
#                 bool,
#                 bool,
#                 bool,
#                 bool,
#                 bool,
#                 bool,
#                 bool,
#                 bool,
#             ],  # 手柄数据（用于调试）
#             Data.TEMPERATURE: [short],  # 温度
#             Data.SERVO: [
#                 double,
#                 double,
#                 double,
#                 double,
#             ],  # 四个舵机的转动角度 分别是 左 右 后面的左右 后面的上下
#         }
#
#         self.sum1 = 0  # 校验和初始值
#         self.check_low = 0
#         self.check_high = 0
#         self.rx_buffer = bytearray()  # 数据接收缓冲区
#         self.data_len = 0
#         self.data_cnt = 0
#
#         self.data = {
#             key: ([], False) for key in self.rx_map.keys()
#         }  # 用于存储接收到的数据
#
#     def send_data(self, float_data_list, bool_data_list, ID=0x06):
#         """
#         发送符合协议的数据，包含帧头、数据区和校验和
#         """
#         if len(float_data_list) != 8 or len(bool_data_list) != 8:
#             raise ValueError("必须提供 8 个 float 数据和 8 个 bool 数据")
#
#         # 1. 帧头 0xAA, 0xBB
#         Tx_buffer = bytearray(50)  # 假设最大数据包为 50 字节
#         num = 0
#         sum1 = 0
#
#         Tx_buffer[num] = 0xAA
#         sum1 += Tx_buffer[num]
#         num += 1
#
#         if ID == 0x06:
#             Tx_buffer[num] = 0xBB
#         else:
#             Tx_buffer[num] = ID
#         sum1 += Tx_buffer[num]
#         num += 1
#
#         # 2. 后面四十个字节：8 个 float（每个 4 字节）和 8 个 bool（每个 1 字节）
#         data_bytes = []
#
#         # 将每个 float 转换为字节流
#         for float_value in float_data_list:
#             data_bytes.extend(
#                 struct.pack("!f", float_value)
#             )  # 将浮动数转为 4 字节字节流
#
#         # 将每个 bool 转换为字节流（1 字节）
#         for bool_value in bool_data_list:
#             data_bytes.append(struct.pack("B", bool_value)[0])  # 将布尔值转为 1 字节
#
#         # 将数据添加到缓冲区
#         for byte in data_bytes:
#             Tx_buffer[num] = byte
#             sum1 += byte
#             num += 1
#
#         # 3. 校验和：所有字节的和的最后 16 位
#         checksum = sum1 & 0xFFFF
#         checksum_low = checksum & 0xFF
#         checksum_high = (checksum >> 8) & 0xFF
#
#         # 4. 校验低字节和高字节
#         Tx_buffer[num] = checksum_low
#         Tx_buffer[num + 1] = checksum_high
#
#         # 发送数据
#         self.ser.write(Tx_buffer)
#         print(f"Sent data: {Tx_buffer}")
#
#     def receive_data(self):
#         """
#         接收数据并进行协议解析和校验
#         """
#         # 从串口读取一个字节
#         data = self.ser.read(1)
#         if not data:
#             return
#
#         if self.rxstate == 0 and data == 0xAA:
#             # 帧头 0xAA
#             self.rxstate = 1
#             self.sum1 += data[0]
#             return
#
#         elif self.rxstate == 1 and data == 0xBB:
#             # 帧头 0xBB
#             self.rxstate = 2
#             self.sum1 += data[0]
#             return
#
#         elif self.rxstate == 2:
#             # 接收 ID
#             self.rx_id = data
#             self.rxstate = 3
#             self.sum1 += data[0]
#             return
#
#         elif self.rxstate == 3:
#             self.rx_data = []
#             for value in self.rx_map[Data(self.rx_id)]:
#                 if value is float:
#                     if len(self.rx_buffer) < 4:
#                         self.rx_buffer.extend(data)
#                         return
#                 elif value is bool:
#                     if len(self.rx_buffer) < 1:
#                         self.rx_buffer.extend(data)
#                         return
#                 elif value is short:
#                     if len(self.rx_buffer) < 2:
#                         self.rx_buffer.extend(data)
#                         return
#                 elif value is double:
#                     if len(self.rx_buffer) < 8:
#                         self.rx_buffer.extend(data)
#                         return
#
#             self.rxstate = 4
#
#         elif self.rxstate == 4:
#             # 接收校验低字节
#             self.check_low = data
#             self.rxstate = 5
#             return
#
#         elif self.rxstate == 5:
#             # 接收校验高字节
#             self.check_high = data
#             self.rxstate = 6
#             return
#
#         elif self.rxstate == 6:
#             # 校验和检查
#             total_sum = sum(self.rx_buffer[: self.data_cnt])
#             if total_sum == ((self.check_high << 8) | self.check_low):
#                 # print(f"Valid data received: { self.rx_data }")
#
#                 self.rxstate = 0
#                 self.sum1 = 0
#                 self.data_len = 0
#                 self.data_cnt = 0
#                 self.check_low = 0
#                 self.check_high = 0
#                 self.data[Data(self.rx_id)] = (self.rx_data, True)
#             else:
#                 self.rxstate = 0
#                 self.sum1 = 0
#                 self.data_len = 0
#                 self.data_cnt = 0
#                 self.check_low = 0
#                 self.check_high = 0
#                 print("Checksum error")
#         else:
#             # 其他状态，重置
#             self.rxstate = 0
#
#     def get_data(self, ID):
#         return self.data[ID]
#
#     def close(self):
#         # 关闭串口
#         self.ser.close()
"""
̛̛̾̒̊̈̈̇ͭ̾҉̱̹͙ ̪̖̠̱ͧͬͤͯ̄ͣͨ̚̚͘͠ ̵̸̶̶̸̨̼̜͕͍͈͔̪̘̣̮̖̥̗̪̬͓̠̲̟̻̞̤̳͔͖̥̻͉̮͓̬͓̤̩͉̻̩̘͕̠͍̳̳͔̣̬̰̤̺̹͉̞͚̖̲͈̻̪̜̹͇̭̥̼̹ͮͫ͐̄͐ͯ̑͊ͤͩͬ͛͛̆̐̐͗́̔̊͋̈̐ͥͪ̽ͣͪ̒́̀ͤͬ̃̄̆̈́ͭͣ̇̓̊ͦ̍ͭ͂̽͑ͫ́̽͒̇̾͊ͮͪ̑͑̄̕̕͘͜͢͟͞͝͝͡ͅͅ.̢̬̜͇̳̣̮̩̗͈̝̪̭̲̓̆̄̒̈̊ͧ̈́̋ͥͬ̏͑ͨ͗̿ͨ̃ͧ͒͑̈̚̚҉͖̭̦̲̣͎̗̳̾̓̉̂͑͛ͧ̾̕͞ ͆̆̏̋̄ͤ͏̧̨̧̡̛̳͙͙͚̮̥̙̖̞͈̜͖̱̻̪̗̱̠̼͈̠͔̯̺̳̥͔̱̟̱̥̣͎̫̰̣͕͆̀̈̓̃͋̐̓ͥ̀̐̐̽̑ͦ͑͗͑̄ͥ͒̀̚͟͜͜͡͞͞ͅͅ.̷͎̱̫̗̗̹̥̟̬̲̲͉͇͉̦̼̞͆̾͑̓͛̀̒͆͆͑ͯ͋ͭͬͤ̏ͬͮͤ͘͠͏̸͏̵̬̰̹̬̘͍͖̤̮̮̣͇̥͉̹̝̰͕̼̫̣͔͙̫̋ͬ̇̅ͤ̀̚ͅ҉̷̸̷̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͇͚̝̘̞̯̦͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ͟͠҉̶̴̩̥͎͖̻̜̰̪̙̝̺͕͓̹̱͚̪ͦͣ͐́͆̀̀ͪ̍ͫ͂̇ͬ̑̉̓̍̋ͦ͗̌̌̊͊̊́̚͞.̢͔̮̖̠͇̝̳̪̩̩̥͎͔̞̳̣̻͓̜͍͍̐̊̔́̀͛̎̑͌̓͑̿́̏ͭͫ̀͋͋̐̍ͦͦ̀̄̕̚ͅͅ ̷̷̨̦̖̘̤̱̮̘̪̘̘̦͖̪̟̱̥̟͓̇ͣ̿͗͆̓͆̈́ͨ̓ͫ̆̓ͯ̿̔̑ͧ͛̽ͅ͏̡͇͎̳̣̹̀ͭ̿̂ͩ͑̇̕͟҉̨̠͈̼̲̣̣͖̠͓̞̞̄̾.̵̥͈̝͚̘̣̘͍̘͎̟̳̺̗̬̰̤̪̮̞̝̯̣̖̂̿ͫͣ̊̔ͯ́̋̍͞͠҉̴̧̡̛̲̗̭̫͈̺̗̗̭̮͎̗̫̫͉͉͇͚͎͓̦͊ͤ͋͐́̋̃͛̔͒̒ͥ̇͂̽̌̈̎̀͆͑͆ͨͬ̽͌̍̀̚͘͘͡͡ͅ͏̶̢̘͈̪̗̙̩͚̜̳̘̖͇̲̓̐͂͆ͬͧ́̅͋̍́́́͡ͅ.̡̲̤̯͇̟ͯͪ̽̿ͯ̍ͤ̀҉̷̸̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͖͕͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿͟͠ ̷͇͚̝̘̞̯̦̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ҉̶̴̩̥͎͖̻̜̰̪̙̝̺͕͓̹̱͚̪̱ͦͣ͐́͆̀̀ͪ̍ͫ͂̇ͬ̑̉̓̍̋ͦ͗̌̌̊͊̊́̚͞.̢͔̮̖̠͇̝̳̪̩̩̥͎͔̞̳̣̻͓̜͍͍̐̊̔́̀͛̎̑͌̓͑̿́̏ͭͫ̀͋͋̐̍ͦͦ̀̄̕̚ͅͅ ̷̷̨̦̖̘̤̱̮̘̪̘̘̦͖̪̟̱̇ͣ̿͗͆̓͆̈́ͨ̓ͫ̆̓ͅ[ ̝̦̬̤͖̗͕͎͊̐̊͊̏ͦ̈́̒͆́ͬ̂̕͠ ̛̛̾̒̊̈̈̇ͭ̾҉̱̹͙ ̪̖̠̱ͧͬͤͯ̄ͣͨ̚̚͘͠ ̵̸̶̶̸̨̼̜͕͍͈͔̪̘̣̮̖̥̗̪̬͓̠̲̟̻̞̤̳͔͖̥̻͉̮͓̬͓̤̩͉̻̩̘͕̠͍̳̳͔̣̬̰̤̺̹͉̞͚̖̲͈̻̪̜̹͇̭̥̼̹ͮͫ͐̄͐ͯ̑͊ͤͩͬ͛͛̆̐̐͗́̔̊͋̈̐ͥͪ̽ͣͪ̒́̀ͤͬ̃̄̆̈́ͭͣ̇̓̊ͦ̍ͭ͂̽͑ͫ́̽͒̇̾͊ͮͪ̑͑̄̕̕͘͜͢͟͞͝͝͡ͅͅ.̢̬̜͇̳̣̮̩̗͈̝̪̭̲̓̆̄̒̈̊ͧ̈́̋ͥͬ̏͑ͨ͗̿ͨ̃ͧ͒͑̈̚̚҉͖̭̦̲̣͎̗̳̾̓̉̂͑͛ͧ̾̕͞ ͆̆̏̋̄ͤ͏̧̨̧̡̛̳͙͙͚̮̥̙̖̞͈̜͖̱̻̪̗̱̠̼͈̠͔̯̺̳̥͔̱̟̱̥̣͎̫̰̣͕͆̀̈̓̃͋̐̓ͥ̀̐̐̽̑ͦ͑͗͑̄ͥ͒̀̚͟͜͜͡͞͞ͅͅ.̷͎̱̫̗̗̹̥̟̬̲̲͉͇͉̦̼̞͆̾͑̓͛̀̒͆͆͑ͯ͋ͭͬͤ̏ͬͮͤ͘͠͏̸͏̵̬̰̹̬̘͍͖̤̮̮̣͇̥͉̹̝̰͕̼̫̣͔͙̫̋ͬ̇̅ͤ̀̚ͅ҉̷̸̷̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͇͚̝̘̞̯̦͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ͟͠҉̶̴̩̥͎͖̻̜̰̪̙̝̺͕͓̹̱͚̪ͦͣ͐́͆̀̀ͪ̍ͫ͂̇ͬ̑̉̓̍̋ͦ͗̌̌̊͊̊́̚͞.̢͔̮̖̠͇̝̳̪̩̩̥͎͔̞̳̣̻͓̜͍͍̐̊̔́̀͛̎̑͌̓͑̿́̏ͭͫ̀͋͋̐̍ͦͦ̀̄̕̚ͅͅ ̷̷̨̦̖̘̤̱̮̘̪̘̘̦͖̪̟̱̥̟͓̇ͣ̿͗͆̓͆̈́ͨ̓ͫ̆̓ͯ̿̔̑ͧ͛̽ͅ͏̡͇͎̳̣̹̀ͭ̿̂ͩ͑̇̕͟҉̨̠͈̼̲̣̣͖̠͓̞̞̄̾.̵̥͈̝͚̘̣̘͍̘͎̟̳̺̗̬̰̤̪̮̞̝̯̣̖̂̿ͫͣ̊̔ͯ́̋̍͞͠҉̴̧̡̛̲̗̭̫͈̺̗̗̭̮͎̗̫̫͉͉͇͚͎͓̦͊ͤ͋͐́̋̃͛̔͒̒ͥ̇͂̽̌̈̎̀͆͑͆ͨͬ̽͌̍̀̚͘͘͡͡ͅ͏̶̢̘͈̪̗̙̩͚̜̳̘̖͇̲̓̐͂͆ͬͧ́̅͋̍́́́͡ͅ.̡̲̤̯͇̟ͯͪ̽̿ͯ̍ͤ̀҉̷̸̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͖͕͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿͟͠ ̷͇͚̝̘̞̯̦̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ҉̶̴̩̥͎͖̻̜̰̪̙̝̺͕͓̹̱͚̪̱ͦͣ͐́͆̀̀ͪ̍ͫ͂̇ͬ̑̉̓̍̋ͦ͗̌̌̊͊̊́̚͞.̢͔̮̖̠͇̝̳̪̩̩̥͎͔̞̳̣̻͓̜͍͍̐̊̔́̀͛̎̑͌̓͑̿́̏ͭͫ̀͋͋̐̍ͦͦ̀̄̕̚ͅͅ ̷̷̨̦̖̘̤̱̮̘̪̘̘̦͖̪̟̱̇ͣ̿͗͆̓͆̈́ͨ̓ ̝̦̬̤͖̗͕͎͊̐̊͊̏ͦ̈́̒͆́ͬ̂̕͠ ̛̛̾̒̊̈̈̇ͭ̾҉̱̹͙ ̪̖̠̱ͧͬͤͯ̄ͣͨ̚̚͘͠ ̵̸̶̶̸̨̼̜͕͍͈͔̪̘̣̮̖̥̗̪̬͓̠̲̟̻̞̤̳͔͖̥̻͉̮͓̬͓̤̩͉̻̩̘͕̠͍̳̳͔̣̬̰̤̺̹͉̞͚̖̲͈̻̪̜̹͇̭̥̼̹ͮͫ͐̄͐ͯ̑͊ͤͩͬ͛͛̆̐̐͗́̔̊͋̈̐ͥͪ̽ͣͪ̒́̀ͤͬ̃̄̆̈́ͭͣ̇̓̊ͦ̍ͭ͂̽͑ͫ́̽͒̇̾͊ͮͪ̑͑̄̕̕͘͜͢͟͞͝͝͡ͅͅ.̢̬̜͇̳̣̮̩̗͈̝̪̭̲̓̆̄̒̈̊ͧ̈́̋ͥͬ̏͑ͨ͗̿ͨ̃ͧ͒͑̈̚̚҉͖̭̦̲̣͎̗̳̾̓̉̂͑͛ͧ̾̕͞ ͆̆̏̋̄ͤ͏̧̨̧̡̛̳͙͙͚̮̥̙̖̞͈̜͖̱̻̪̗̱̠̼͈̠͔̯̺̳̥͔̱̟̱̥̣͎̫̰̣͕͆̀̈̓̃͋̐̓ͥ̀̐̐̽̑ͦ͑͗͑̄ͥ͒̀̚͟͜͜͡͞͞ͅͅ.̷͎̱̫̗̗̹̥̟̬̲̲͉͇͉̦̼̞͆̾͑̓͛̀̒͆͆͑ͯ͋ͭͬͤ̏ͬͮͤ͘͠͏̸͏̵̬̰̹̬̘͍͖̤̮̮̣͇̥͉̹̝̰͕̼̫̣͔͙̫̋ͬ̇̅ͤ̀̚ͅ҉̷̸̷̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͇͚̝̘̞̯̦͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ͟͠҉̶̴̩̥͎͖̻̜̰̪̙̝̺͕͓̹̱͚̪ͦͣ͐́͆̀̀ͪ̍ͫ͂̇ͬ̑̉̓̍̋ͦ͗̌̌̊͊̊́̚͞.̢͔̮̖̠͇̝̳̪̩̩̥͎͔̞̳̣̻͓̜͍͍̐̊̔́̀͛̎̑͌̓͑̿́̏ͭͫ̀͋͋̐̍ͦͦ̀̄̕̚ͅͅ ̷̷̨̦̖̘̤̱̮̘̪̘̘̦͖̪̟̱̥̟͓̇ͣ̿͗͆̓͆̈́ͨ̓ͫ̆̓ͯ̿̔̑ͧ͛̽ͅ͏̡͇͎̳̣̹̀ͭ̿̂ͩ͑̇̕͟҉̨̠͈̼̲̣̣͖̠͓̞̞̄̾.̵̥͈̝͚̘̣̘͍̘͎̟̳̺̗̬̰̤̪̮̞̝̯̣̖̂̿ͫͣ̊̔ͯ́̋̍͞͠҉̴̧̡̛̲̗̭̫͈̺̗̗̭̮͎̗̫̫͉͉͇͚͎͓̦͊ͤ͋͐́̋̃͛̔͒̒ͥ̇͂̽̌̈̎̀͆͑͆ͨͬ̽͌̍̀̚͘͘͡͡ͅ͏̶̢̘͈̪̗̙̩͚̜̳̘̖͇̲̓̐͂͆ͬͧ́̅͋̍́́́͡ͅ.̡̲̤̯͇̟ͯͪ̽̿ͯ̍ͤ̀҉̷̸̨͍̺̟̳͔̞̙̳̳͕͖̬̮̳̥͖͕͂̿͆ͯ̋̒̇ͨ́͋̄̃͌̉̈ͮ̿͟͠ ̷͇͚̝̘̞̯̦̾ͬ̋̌̂͑ͤ̓ͭ̀͒̌̑̒̎͊͆ͬͬ҉̶̴
"""

logger = logging.getLogger(__name__)


class Data(enum.Enum):
    DEPTH = 7
    ATTITUDE = 5
    JOYSTICK = 6
    TEMPERATURE = 8
    SERVO = 9


class short:
    pass


class double:
    pass


class serialProtocol(asyncio.Protocol):
    def __init__(self, head=b"\xaa\xbb"):
        self.loop = asyncio.get_event_loop()
        self.head = head
        self.buffer = b""
        self.receiving = None

        self.rx_map = {  # 由类型组成的字典
            Data.DEPTH: [float],  # 深度
            Data.ATTITUDE: [float, float, float],  # Roll, Pitch, Yaw
            Data.JOYSTICK: [
                float,
                float,
                float,
                float,
                float,
                float,
                float,
                float,
                bool,
                bool,
                bool,
                bool,
                bool,
                bool,
                bool,
                bool,
            ],  # 手柄数据（用于调试）
            Data.TEMPERATURE: [short],  # 温度
            Data.SERVO: [
                float,
                float,
                float,
                float,
            ],  # 四个舵机的转动角度 分别是 左 右 后面的左右 后面的上下
        }

        self.sum = 0  # 校验和初始值
        self.check_low = 0
        self.check_high = 0
        self.data_len = 0
        self.data = []

        self.server_protocol = None  # 用于发送数据的协议实例

    def connection_made(self, transport):
        serial_tran = cast(serial_asyncio.SerialTransport, transport)
        self.transport = serial_tran
        assert(self.transport.serial is not None)
        self.transport.serial.rts = False
        print("Connection established")

    def data_received(self, data):
        self.buffer += data
        if len(self.buffer) > 265:
            self.buffer = self.buffer[-265:]  # 保持缓冲区大小不超过265字节

        # logger.debug(f"Received data: f{data}")
        print("Received data:", data)
        if not self.receiving:
            start = self.buffer.find(self.head)
            if start != -1 and start < len(self.buffer):
                self.sum += 0xAA + 0xBB
                self.buffer = self.buffer[start + len(self.head) :]
                self.receiving = Data(self.buffer[0])
                self.buffer = self.buffer[1:]
                for type in self.rx_map[self.receiving]:
                    if type is float:
                        self.data_len += 4
                    if type is bool:
                        self.data_len += 1
                    if type is short:
                        self.data_len += 2
                    if type is double:
                        self.data_len += 8
            else:
                return
        else:
            if len(self.buffer) < self.data_len + 2:
                return
            else:
                self.sum += sum(self.buffer[: self.data_len])
                checksum = (
                    self.buffer[self.data_len] | self.buffer[self.data_len + 1] << 8
                )
                if self.sum != checksum:
                    print(f"Checksum error: {self.sum} != {checksum}")
                else:
                    format_string = ""
                    for type_ in self.rx_map[self.receiving]:
                        if type_ is float:
                            format_string += "f"
                        elif type_ is bool:
                            format_string += "?"
                        elif type_ is short:  # 注意：应确保 short 定义为 struct 的 'h'
                            format_string += "h"
                        elif type_ is double:
                            format_string += "d"
                    data_bytes = self.buffer[: self.data_len]
                    self.data.extend(struct.unpack("!" + format_string, data_bytes))
                    map = {"type": Data(self.receiving).name, "data": self.data}
                    json_string = json.dumps(map, ensure_ascii=True)
                    if self.server_protocol:
                        self.server_protocol.schedule_send(json_string)

                self.buffer = self.buffer[self.data_len + 2 :]
                self.receiving = None
                self.sum = 0

    def connection_lost(self, exc):
        print("Connection lost")

    def schedule_send(self, floats: list, bools: list):
        formatted_floats = struct.pack("!8f", *floats)
        formatted_bools = struct.pack("!8?", *bools)
        check_sum = 0xAA + 0xBB + sum(formatted_floats) + sum(formatted_bools)
        check_low = check_sum & 0xFF
        check_high = (check_sum >> 8) & 0xFF
        message = (
            b"\xaa\xbb"
            + formatted_floats
            + formatted_bools
            + check_low.to_bytes(1, "big")
            + check_high.to_bytes(1, "big")
        )

        def send():
            self.transport.write(message)

        self.loop.call_soon(send)


def choose_serial_port():
    # 获取所有可用的串口
    ports = list(list_ports.comports())

    if len(ports) == 0:
        print("没有找到可用的串口设备。")
        return None

    # 显示所有可用串口及其信息
    print("可用的串口设备:")
    for i, port in enumerate(ports):
        print(f"{i + 1}: {port.device} - {port.description}")

    H340_like_ports = [p for p in ports if "H340" in p.description]
    if H340_like_ports:
        print(f"找到 H340 类型的串口设备：{H340_like_ports[0].description}")
        return H340_like_ports[0].device

    # 提示用户选择一个端口
    while True:
        try:
            choice = int(input("请输入要选择的串口编号: ")) - 1
            if 0 <= choice < len(ports):
                selected_port = ports[choice].device
                print(f"您选择了串口: {selected_port}")
                return selected_port
            else:
                print("无效的选择，请输入有效的编号。")
        except ValueError:
            print("无效输入，请输入数字。")


async def initSerial():
    port = choose_serial_port()
    loop = asyncio.get_event_loop()
    coro = serial_asyncio.create_serial_connection(
        loop, serialProtocol, port, baudrate=115200
    )
    # serial_transport, serial_protocol = loop.run_until_complete(coro)

    serial_transport, serial_protocol = await coro
    return serial_transport, serial_protocol


if __name__ == "__main__":

    serial_protocol = None
    loop = asyncio.get_event_loop()
    async def start():
        global serial_protocol
        serial_transport, serial_protocol = await initSerial()
    
    loop.run_until_complete(start())
    async def send_loop():
        while True:
            assert(serial_protocol is not None)
            serial_protocol.schedule_send(
                [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
                [True, False, True, False, True, False, True, False],
            )
            await asyncio.sleep(0.5)
    loop.run_until_complete(send_loop())
    # async def send_loop():
    #     while True:
    #         # 发送数据
    #         serial_protocol.schedule_send(
    #             [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
    #             [True, False, True, False, True, False, True, False],
    #         )
    #         await asyncio.sleep(1)
    # loop.run_until_complete(serial_protocol.awaiter())
    # port = choose_serial_port()
    # handler = Serial(port, 115200)
    # try:
    #     # 主线程可以做一些其他任务，或者等待两个线程完成
    #     while True:
    #         # 发送数据
    #         handler.send_data(
    #             [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
    #             [True, False, True, False, True, False, True, False],
    #         )
    #         # 接收数据
    #         handler.receive_data()
    #         time.sleep(1)
    # except KeyboardInterrupt:
    #     print("Terminating program.")
    # finally:
    #     handler.close()