import socket

# 1. 创建 socket 对象
#    AF_INET = IPv4, SOCK_STREAM = TCP (面向连接的流式传输)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 2. 设置超时（重要！防止程序永远卡在等待上）
sock.settimeout(5.0)  # 5秒超时

# 3. 连接到设备（IP地址, 端口号）
sock.connect(('192.168.1.100', 5000))

# 4. 发送数据（必须是 bytes 类型）
sock.sendall(b'HELLO\n')

# 5. 接收数据（最多接收 1024 字节）
response = sock.recv(1024)
print(f"收到回复: {response}")

# 6. 关闭连接
sock.close()

import time

def reconnect_with_backoff(connect_func, max_delay=30, stop_event=None):
    """带指数退避的重连逻辑。
    
    Args:
        connect_func: 一个无参数的函数，返回 True 表示连接成功，False 表示失败
        max_delay: 最大等待秒数
        stop_event: threading.Event，用于外部停止重连循环
    """
    delay = 1  # 初始等待 1 秒
    
    while True:
        if stop_event and stop_event.is_set():
            return False
        
        try:
            if connect_func():
                print("连接成功！")
                return True
        except Exception as e:
            print(f"连接失败: {e}")
        
        print(f"将在 {delay} 秒后重试...")
        time.sleep(delay)
        delay = min(delay * 2, max_delay)  # 翻倍，但不超过上限

import socket

def simple_tcp_client(host, port):
    """最简单的 TCP 客户端，没有任何容错能力。"""
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(5.0)
    sock.connect((host, port))
    
    # 发送命令
    sock.sendall(b'STATUS\n')
    
    # 接收响应
    data = sock.recv(4096)
    print(f"收到: {data.decode()}")
    
    sock.close()

# 使用
simple_tcp_client('192.168.1.100', 5000)

import socket
import threading
import time
from enum import Enum


class ConnState(Enum):
    """连接状态枚举"""
    IDLE = "idle"
    CONNECTED = "connected"
    RECONNECTING = "reconnecting"
    STOPPED = "stopped"


class RobustTCPClient:
    """健壮的 TCP 客户端：支持心跳保活与自动重连。
    
    典型用法：
        client = RobustTCPClient('192.168.1.100', 5000)
        client.on_data = lambda data: print(f"收到: {data}")
        client.start()  # 后台线程运行，非阻塞
        # ... 主线程做其他事 ...
        client.send(b'GET_STATUS\n')  # 线程安全地发送数据
        client.stop()  # 优雅关闭
    """

    def __init__(self, host: str, port: int,
                 heartbeat_interval: float = 5.0,
                 heartbeat_timeout: float = 3.0,
                 reconnect_max_delay: float = 30.0,
                 heartbeat_payload: bytes = b'\n'):
        """
        Args:
            host: 设备 IP 地址
            port: 设备端口号
            heartbeat_interval: 心跳发送间隔（秒）
            heartbeat_timeout: 心跳响应等待超时（秒）
            reconnect_max_delay: 重连最大等待时间（秒）
            heartbeat_payload: 心跳包内容（默认一个换行符，根据协议可改为 PING 等）
        """
        self.host = host
        self.port = port
        self.heartbeat_interval = heartbeat_interval
        self.heartbeat_timeout = heartbeat_timeout
        self.reconnect_max_delay = reconnect_max_delay
        self.heartbeat_payload = heartbeat_payload

        # 内部状态
        self._sock: socket.socket = None
        self._state = ConnState.IDLE
        self._send_lock = threading.Lock()
        self._stop_event = threading.Event()
        self._heartbeat_ack = threading.Event()  # 用于等待心跳响应

        # 回调函数（由外部设置）
        self.on_data = None      # func(data: bytes) - 收到数据时回调
        self.on_connected = None  # func() - 连接建立时回调
        self.on_disconnected = None  # func() - 连接断开时回调

    @property
    def is_connected(self) -> bool:
        return self._state == ConnState.CONNECTED

    # ========== 连接管理 ==========

    def _do_connect(self) -> bool:
        """执行一次连接尝试。返回是否成功。"""
        try:
            # 关闭旧连接（如果有）
            self._safe_close_sock()

            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
            sock.settimeout(5.0)
            sock.connect((self.host, self.port))
            sock.settimeout(0.5)  # 连接成功后设为小超时，用于 recv 循环

            self._sock = sock
            self._state = ConnState.CONNECTED
            print(f"[TCP] 已连接 {self.host}:{self.port}")

            if self.on_connected:
                self.on_connected()
            return True

        except (OSError, socket.timeout, ConnectionRefusedError) as e:
            print(f"[TCP] 连接失败: {e}")
            self._safe_close_sock()
            return False

    def _safe_close_sock(self):
        """安全关闭 socket，不抛异常。"""
        if self._sock:
            try:
                self._sock.close()
            except OSError:
                pass
            self._sock = None

    def _handle_disconnect(self, reason: str = ""):
        """处理连接断开：更新状态、通知外部、触发重连。"""
        if self._state != ConnState.CONNECTED:
            return  # 已经在处理断开了，避免重复

        self._state = ConnState.RECONNECTING
        self._safe_close_sock()
        print(f"[TCP] 连接断开: {reason}")

        if self.on_disconnected:
            self.on_disconnected()

        # 在当前线程中执行重连（此方法通常由 recv 或 heartbeat 线程调用）
        self._reconnect_loop()

    def _reconnect_loop(self):
        """指数退避重连循环。"""
        delay = 1.0
        while not self._stop_event.is_set():
            print(f"[TCP] 将在 {delay:.0f} 秒后尝试重连...")
            # 可中断的等待
            if self._stop_event.wait(timeout=delay):
                return  # 收到停止信号

            if self._do_connect():
                return  # 重连成功

            delay = min(delay * 2, self.reconnect_max_delay)

    # ========== 数据收发 ==========

    def send(self, data: bytes) -> bool:
        """线程安全的数据发送。返回是否成功。"""
        with self._send_lock:
            if self._state != ConnState.CONNECTED or not self._sock:
                return False
            try:
                self._sock.sendall(data)
                return True
            except (BrokenPipeError, OSError) as e:
                # 发送失败说明连接已断
                threading.Thread(
                    target=self._handle_disconnect,
                    args=(f"发送失败: {e}",),
                    daemon=True
                ).start()
                return False

    def _recv_loop(self):
        """接收线程：持续读取 socket 数据。"""
        while not self._stop_event.is_set():
            if self._state != ConnState.CONNECTED:
                time.sleep(0.2)
                continue
            try:
                data = self._sock.recv(4096)
                if not data:
                    # recv 返回空 bytes 表示对端关闭了连接
                    self._handle_disconnect("对端关闭连接")
                    continue

                # 收到任何数据都更新心跳状态（说明连接是活的）
                self._heartbeat_ack.set()

                if self.on_data:
                    self.on_data(data)

            except socket.timeout:
                # 超时是正常的，继续循环
                continue
            except OSError as e:
                self._handle_disconnect(f"接收异常: {e}")

    def _heartbeat_loop(self):
        """心跳线程：定时发送心跳包，检测连接活性。"""
        while not self._stop_event.is_set():
            # 等待心跳间隔（可被 stop_event 中断）
            if self._stop_event.wait(timeout=self.heartbeat_interval):
                return

            if self._state != ConnState.CONNECTED:
                continue

            # 清除上次的心跳确认标志
            self._heartbeat_ack.clear()

            # 发送心跳包
            if not self.send(self.heartbeat_payload):
                # send 内部已经触发了断连处理
                continue

            # 等待心跳响应（任何数据都可以算作响应）
            if not self._heartbeat_ack.wait(timeout=self.heartbeat_timeout):
                # 超时未收到任何数据，判定连接已死
                self._handle_disconnect("心跳超时，无响应")

    # ========== 生命周期管理 ==========

    def start(self) -> bool:
        """启动客户端：连接设备，并启动后台收发线程。返回是否连接成功。"""
        self._stop_event.clear()

        if not self._do_connect():
            # 首次连接失败，启动后台重连
            self._state = ConnState.RECONNECTING
            threading.Thread(target=self._reconnect_loop, daemon=True).start()

        # 启动接收线程和心跳线程
        threading.Thread(target=self._recv_loop, daemon=True).start()
        threading.Thread(target=self._heartbeat_loop, daemon=True).start()
        return self.is_connected

    def stop(self):
        """优雅停止客户端。"""
        self._stop_event.set()
        self._state = ConnState.STOPPED
        self._safe_close_sock()
        print("[TCP] 客户端已停止")

import time

# 创建客户端实例
client = RobustTCPClient(
    host='192.168.1.100',
    port=5000,
    heartbeat_interval=5,     # 每 5 秒发一次心跳
    heartbeat_timeout=3,      # 3 秒内无响应判定断线
    reconnect_max_delay=30    # 重连最长等待 30 秒
)

# 设置回调
def on_data(data):
    print(f"[收到数据] {data}")

def on_connected():
    print("[事件] 连接已建立")

def on_disconnected():
    print("[事件] 连接已断开")

client.on_data = on_data
client.on_connected = on_connected
client.on_disconnected = on_disconnected

# 启动（非阻塞，后台线程运行）
client.start()

# 主线程可以自由地发送命令
while True:
    cmd = input("输入命令（q 退出）: ")
    if cmd.strip().lower() == 'q':
        break
    client.send((cmd.strip() + '\n').encode())

client.stop()

[TCP] 已连接 192.168.1.100:5000
[事件] 连接已建立
输入命令（q 退出）: STATUS
[收到数据] b'STATUS:OK,FAN=1200RPM,TEMP=45.2C\n'
输入命令（q 退出）: 
# ← 此时拔掉设备网线
[TCP] 连接断开: 心跳超时，无响应
[事件] 连接已断开
[TCP] 将在 1 秒后尝试重连...
[TCP] 连接失败: [Errno 113] No route to host
[TCP] 将在 2 秒后尝试重连...
[TCP] 连接失败: [Errno 113] No route to host
[TCP] 将在 4 秒后尝试重连...
# ← 此时插回网线，设备重启完成
[TCP] 已连接 192.168.1.100:5000
[事件] 连接已建立

import socket
import json
import time


def discover_devices(discovery_port: int = 5000,
                     broadcast_msg: str = "DISCOVER",
                     listen_timeout: float = 3.0) -> list:
    """在局域网中广播发现设备。
    
    Args:
        discovery_port: 设备监听的 UDP 端口号
        broadcast_msg: 广播消息内容（设备端收到后会回复自身信息）
        listen_timeout: 等待设备回复的超时时间（秒）
    
    Returns:
        发现的设备列表，每个元素为 dict，包含 'ip', 'port' 及设备回复的其他字段
    
    使用前提：
        设备端需实现以下逻辑：
        1. 监听 discovery_port 的 UDP 数据包
        2. 收到 broadcast_msg 后，回复一个 JSON 字符串，如：
           {"name": "Sensor-01", "firmware": "v2.1", "tcp_port": 5001}
    """
    found_devices = []

    # 创建 UDP socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)  # 允许广播
    sock.settimeout(listen_timeout)

    try:
        # 发送广播消息
        # '<broadcast>' 是 Python 的特殊地址，表示 255.255.255.255
        sock.sendto(broadcast_msg.encode(), ('<broadcast>', discovery_port))
        print(f"[发现] 已向端口 {discovery_port} 发送广播，等待设备回复...")

        # 循环接收所有回复，直到超时
        while True:
            try:
                data, (ip, port) = sock.recvfrom(4096)
                print(f"[发现] 收到来自 {ip}:{port} 的回复")

                # 尝试解析 JSON 格式的设备信息
                try:
                    device_info = json.loads(data.decode())
                    device_info['ip'] = ip  # 将发送方 IP 也记录进去
                    found_devices.append(device_info)
                except (json.JSONDecodeError, UnicodeDecodeError):
                    # 如果不是 JSON，就当纯文本记录
                    found_devices.append({
                        'ip': ip,
                        'raw_response': data.decode(errors='replace')
                    })

            except socket.timeout:
                # 超时，不再等待更多回复
                break

    finally:
        sock.close()

    print(f"[发现] 共发现 {len(found_devices)} 台设备")
    return found_devices


# ========== 使用示例 ==========
if __name__ == '__main__':
    devices = discover_devices(discovery_port=5000, listen_timeout=3.0)

    print("\n===== 发现的设备列表 =====")
    for i, dev in enumerate(devices, 1):
        print(f"  [{i}] IP: {dev.get('ip')}")
        for key, value in dev.items():
            if key != 'ip':
                print(f"      {key}: {value}")
        print()

[发现] 已向端口 5000 发送广播，等待设备回复...
[发现] 收到来自 192.168.1.101:5000 的回复
[发现] 收到来自 192.168.1.102:5000 的回复
[发现] 收到来自 192.168.1.103:5000 的回复
[发现] 共发现 3 台设备

===== 发现的设备列表 =====
  [1] IP: 192.168.1.101
      name: Sensor-01
      firmware: v2.1
      tcp_port: 5001

  [2] IP: 192.168.1.102
      name: Sensor-02
      firmware: v1.5
      tcp_port: 5001

  [3] IP: 192.168.1.103
      name: Controller-01
      firmware: v3.1
      tcp_port: 5001

# 1. 发现设备
devices = discover_devices(discovery_port=5000)

if not devices:
    print("未发现任何设备！")
    exit(1)

# 2. 让用户选择（或自动选择第一个）
target = devices[0]
print(f"连接到 {target['name']} ({target['ip']}:{target['tcp_port']})")

# 3. 建立 TCP 连接
client = RobustTCPClient(
    host=target['ip'],
    port=target.get('tcp_port', 5001)
)
client.on_data = lambda d: print(f"设备数据: {d}")
client.start()

# 4. 正常业务通讯...
# ...

我需要为一个嵌入式设备编写 TCP 客户端。设备通讯协议如下：

【设备信息】
- IP: 动态分配，需要先通过 UDP 广播发现（发现端口 5000）
- TCP 端口: 5001
- 编码: UTF-8 文本协议，以 \n 分隔命令

【命令列表】
- 查询状态: 发送 "STATUS\n"，设备回复 "STATUS:<JSON数据>\n"
- 设置参数: 发送 "SET:<key>=<value>\n"，设备回复 "OK\n" 或 "ERR:<原因>\n"
- 心跳: 发送 "PING\n"，设备回复 "PONG\n"

【需求】
1. 使用 Python 标准库 socket
2. 实现 UDP 广播发现（发送 "DISCOVER" 到端口 5000，解析 JSON 回复）
3. TCP 连接建立后，每 5 秒发送一次 "PING\n" 作为心跳
4. 如果 3 秒内没收到 PONG，判定连接断开
5. 断线后自动重连，使用指数退避（初始 1 秒，最大 30 秒）
6. 接收和发送分别在不同线程
7. 代码需要详细的中文注释
8. 需要提供一个简洁的使用示例

请生成完整的可运行代码。

以下是两台设备通过 TCP 通讯的 Wireshark 抓包数据。
请帮我分析通讯协议的格式，并生成对应的 Python 解析代码。

【已知信息】
- 这是一个温湿度传感器与上位机的通讯
- 通讯使用 TCP，端口 5001
- 上位机发送命令，传感器回复数据

【Wireshark 抓包数据】
（粘贴抓包数据）

请分析：
1. 请求和响应的配对关系（哪个请求对应哪个响应）
2. 数据包的帧格式（起始符、长度、命令字、数据域、校验等）
3. 命令字的含义分类
4. 是否有心跳机制
5. 存在哪些异常或值得注意的模式

然后，生成 Python 代码实现：
1. 一个能正确解析响应帧的函数
2. 一个能构建请求帧的函数
3. 简要说明你做出的判断依据