1. 为什么选择本地MQTT服务器？从零开始的物联网控制方案

很多刚接触物联网的朋友，可能都尝试过用一些公共的MQTT服务器来做测试，比如EMQX Cloud或者一些免费的公共Broker。这确实很方便，但用久了你会发现几个痛点：一是网络延迟不稳定，有时候控制指令要等一两秒才到设备上；二是数据隐私问题，你的设备状态和控制指令都在别人的服务器上流转；三是功能受限，很多高级的配置和规则引擎没法用。我自己在项目里就遇到过，半夜调试的时候公共服务突然维护，整个测试流程都卡住了。

所以，我强烈建议，如果你是想正经做物联网开发，哪怕只是个人项目，也最好从搭建一个本地MQTT服务器开始。这听起来好像很复杂，但其实比你想象的要简单得多。今天我要分享的，就是如何用EMQX这个开源的MQTT消息服务器，在你自己的电脑上快速搭一个高性能的“消息中转站”，然后用一块几十块钱的ESP32开发板，通过MicroPython编程，实现一个实实在在的远程控制小项目——比如控制一个LED灯的开关。整个过程，从软件安装到代码跑通，顺利的话半小时内就能搞定。

这个方案特别适合谁呢？如果你是学生、创客、物联网方向的开发者，或者只是对智能硬件感兴趣想自己动手玩一玩，那这个组合就是你的“黄金搭档”。EMQX负责稳定可靠的消息路由，ESP32作为功能强大又便宜的硬件终端，MicroPython则让编程变得像写Python脚本一样简单。你不用去啃复杂的C++嵌入式开发，也能快速实现想法。接下来，我就带你一步步走通这个流程，我会把我在实际配置和编码中踩过的坑、需要注意的细节都告诉你，保证你跟着做就能成功。

2. 5分钟搞定EMQX：本地MQTT服务器的安装与配置

搭建本地服务器的第一步，就是安装EMQX。我选择它的原因很简单：性能强、资源消耗相对低、文档全、对开源用户友好。它提供了几乎所有主流系统的安装包，我们这里以最通用的方式来说明。

2.1 下载与一键启动

首先，访问EMQX的官方网站，找到开源版的下载页面。选择对应你操作系统的版本。我以macOS为例，下载下来通常是一个压缩包（比如 emqx-macos-xx.zip）。Windows用户就下 .zip 包，Linux用户可以选择 tar.gz 包或者直接用包管理器安装。

下载完成后，解压到你喜欢的目录，比如 ~/Downloads/emqx。打开终端，进入这个解压后的目录。关键的一步来了，在macOS上，你可能会遇到因为安全策略无法直接运行的情况。别慌，这不是你的问题。如果执行 ./bin/emqx start 提示权限错误，你需要运行下面这个命令来解除系统的安全限制：

sudo xattr -r -d com.apple.quarantine ./emqx

这个命令的作用是移除系统给这个应用打上的“隔离”属性标记。执行完毕后，再运行启动命令：

./bin/emqx start

你会看到一串启动日志，最后出现 “EMQX 启动成功！” 的字样。就这么简单，你的本地MQTT服务器就已经在后台运行起来了！Windows用户更简单，解压后直接双击 bin\emqx start 这个批处理文件（或者用命令行进入目录执行）即可。Linux用户如果使用 tar.gz 包，流程和macOS几乎一样。

2.2 登录控制台与基础检查

服务器启动后，它同时开启了一个非常强大的Web管理控制台。打开你的浏览器，输入地址：http://localhost:18083。这就是EMQX的“驾驶舱”。默认的用户名是 admin，密码是 public。强烈建议你第一次登录后就立刻修改这个密码，毕竟“public”这个密码太公开了。

登录进去后，你会看到一个仪表盘，上面显示了当前的连接数、消息吞吐量等信息。现在因为还没设备连接，所以大部分数据都是0。我们先来确认一下服务器最重要的MQTT服务端口是否正常。EMQX默认使用 1883端口 用于非加密的MQTT连接，这也是我们等下ESP32要连接的端口。你可以在控制台的“监控” -> “监听器”页面里，看到 tcp:default 监听器正在 0.0.0.0:1883 上运行。看到这个，就说明MQTT服务已经就绪，可以接受来自你局域网内任何设备的连接了。

这里有个小技巧：为了让我们局域网里的ESP32能连接到这台运行在你电脑上的EMQX，你需要知道你电脑在局域网里的IP地址。在macOS或Linux终端里输入 ifconfig，在Windows里输入 ipconfig，找到类似于 192.168.1.xxx 或 10.0.0.xxx 这样的地址，记下它。等下在ESP32的代码里，我们就要用这个IP地址，而不是 localhost。

3. 准备你的硬件：ESP32与MicroPython环境搭建

服务器准备好了，接下来轮到我们的硬件主角——ESP32。这块小板子以其双核处理器、Wi-Fi和蓝牙功能以及极低的价格，成为了物联网项目的首选。而MicroPython，可以理解为Python 3的一个精简版，它直接运行在ESP32这样的微控制器上，让我们能用Python语法轻松操作GPIO、连接网络，大大降低了开发门槛。

3.1 给ESP32刷入MicroPython固件

拿到一块新的ESP32，第一步是给它安装MicroPython的“操作系统”。你需要准备一根Micro-USB数据线（就是安卓手机常用的那种），用于给ESP32供电和传输数据。

首先，去MicroPython官网下载针对ESP32的最新稳定版固件文件，通常是一个 .bin 文件。接着，我们需要一个刷机工具。我常用的是 esptool.py，它是一个Python脚本，用pip就能安装：

pip install esptool

安装好后，用数据线将ESP32连接到电脑。然后，我们需要先擦除芯片里原有的内容。在终端里，你需要找到ESP32对应的串口号。在macOS上通常是 /dev/cu.usbserial-XXXX，在Windows上是 COMX（比如COM3）。执行擦除命令（请将 PORT 替换为你的实际串口）：

esptool.py --chip esp32 --port PORT erase_flash

擦除完成后，就可以写入新的MicroPython固件了。命令如下（同样替换 PORT 和 FIRMWARE.bin 的路径）：

esptool.py --chip esp32 --port PORT write_flash -z 0x1000 FIRMWARE.bin

等待进度条走完，看到“Hard resetting...”的提示，固件就刷写成功了。整个过程如果遇到驱动问题，可能需要安装一下CP210x或CH340的USB转串口芯片驱动，根据你的ESP32型号来决定，网上教程很多。

3.2 连接ESP32与编写第一个程序

刷机完成后，我们需要一个工具来和ESP32上的MicroPython交互。我推荐使用 Thonny 这个IDE，它对MicroPython的支持非常友好，自带REPL（交互式命令行）和文件管理功能。

安装并打开Thonny，在右下角选择解释器，选择“MicroPython (ESP32)”，并选择正确的串口。点击连接，如果一切正常，下方的Shell窗口会出现 >>> 提示符，这表明你已经成功连接到了ESP32的MicroPython环境！你可以尝试输入 print("Hello ESP32!") 并回车，看看输出。

接下来，我们要让ESP32连接上你家的Wi-Fi。在Thonny里新建一个文件，输入以下代码，并保存到ESP32设备上，命名为 boot.py。MicroPython启动时会自动运行这个文件。

import network
import time

def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('正在连接网络...')
        wlan.connect(ssid, password)
        # 等待连接，最多20秒
        for i in range(20):
            if wlan.isconnected():
                break
            print(f'等待...{i+1}')
            time.sleep(1)
    if wlan.isconnected():
        print('网络配置:', wlan.ifconfig())
    else:
        print('连接失败！')

# 替换成你的Wi-Fi信息
WIFI_SSID = "你的Wi-Fi名称"
WIFI_PASSWORD = "你的Wi-Fi密码"

connect_wifi(WIFI_SSID, WIFI_PASSWORD)

保存后，在Shell窗口按Ctrl+D软重启ESP32，你会看到它尝试连接Wi-Fi并打印出获取到的IP地址。看到IP地址，就说明网络通了，这是通往物联网世界的关键一步。

4. 核心实战：编写MicroPython MQTT客户端与控制逻辑

网络通了，服务器也准备好了，现在我们要让ESP32成为一个MQTT客户端，能够订阅主题接收指令，并执行相应的动作。我们用一个最经典的例子：通过MQTT消息控制ESP32板载的LED灯（通常是GPIO2上的那个蓝色小灯）。

4.1 引入MQTT客户端库

MicroPython的标准库没有内置完整的MQTT客户端，但社区有一个非常精简高效的实现，通常叫 umqtt.simple。我们需要将这个库文件上传到ESP32。你可以在MicroPython的官方GitHub库或很多开源项目里找到 umqtt 文件夹。我们只需要其中的 simple.py 文件。

在Thonny中，新建一个文件，将 umqtt.simple 的代码完整复制进去（代码较长，就是原始文章里 umqttsimple.py 的内容，这里为了节省篇幅不重复贴出，你可以直接从原始文章复制，或者从可靠的GitHub仓库获取）。然后将其保存到ESP32设备上，文件名为 umqttsimple.py。这个文件封装了所有MQTT协议通信的底层细节，我们直接调用就行。

4.2 编写主控制程序

有了MQTT库，我们就可以编写主程序了。新建一个文件，命名为 main.py（MicroPython会自动运行 main.py）。下面是详细的代码和逐行解释：

import time
import network
from machine import Pin
from umqttsimple import MQTTClient  # 导入我们上传的MQTT库

# 1. 配置信息 - 这里需要你根据实际情况修改！
WIFI_SSID = '你的Wi-Fi名称'
WIFI_PASSWORD = '你的Wi-Fi密码'
# 这里填你电脑的局域网IP地址，就是前面用ifconfig/ipconfig查到的那个
MQTT_SERVER = '192.168.1.100'
# MQTT客户端ID，可以随意，但在同一个服务器上要唯一
CLIENT_ID = 'esp32_led_controller'

# 2. 连接Wi-Fi的函数
def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('正在连接Wi-Fi...')
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        # 增加等待时间和重试机制，更稳定
        max_wait = 30
        while max_wait > 0:
            if wlan.isconnected():
                break
            max_wait -= 1
            print('等待连接...', 30 - max_wait)
            time.sleep(1)
        if not wlan.isconnected():
            # 如果连接失败，可以尝试重新激活接口
            print('连接失败，尝试重新连接...')
            wlan.disconnect()
            wlan.active(False)
            time.sleep(1)
            wlan.active(True)
            wlan.connect(WIFI_SSID, WIFI_PASSWORD)
            time.sleep(5) # 再给一次机会
    if wlan.isconnected():
        print('Wi-Fi连接成功！')
        print('IP地址:', wlan.ifconfig()[0])
        return True
    else:
        print('无法连接到Wi-Fi')
        return False

# 3. MQTT消息回调函数 - 收到消息后自动执行
def mqtt_callback(topic, message):
    # 收到的topic和message是字节类型，需要解码成字符串
    topic_str = topic.decode('utf-8')
    msg_str = message.decode('utf-8')
    print(f'收到消息! 主题: {topic_str}, 内容: {msg_str}')

    # 判断是否是我们关心的控制主题
    if topic_str == 'home/living_room/led':
        if msg_str == 'on':
            led_pin.value(1)  # 高电平点亮LED
            print("LED已打开")
        elif msg_str == 'off':
            led_pin.value(0)  # 低电平熄灭LED
            print("LED已关闭")
        elif msg_str == 'toggle':
            # 翻转LED状态，这是一个很实用的功能
            led_pin.value(not led_pin.value())
            print("LED状态已翻转")
        else:
            print(f'未知指令: {msg_str}')
    # 你可以在这里添加更多主题的判断，控制不同的设备
    # elif topic_str == 'home/fan/switch':
    #     ...

# 4. 主程序逻辑
print("=== ESP32 MQTT远程控制程序启动 ===")

# 第一步：连接Wi-Fi
if not connect_wifi():
    # 如果Wi-Fi连接失败，程序可以在这里进入深度睡眠或者重启
    print("Wi-Fi连接失败，程序停止。")
    # machine.deepsleep(10000)  # 深度睡眠10秒后重启
    # 或者直接重启
    # machine.reset()
    import sys
    sys.exit()

# 第二步：初始化硬件 - 这里控制板载LED (GPIO2)
led_pin = Pin(2, Pin.OUT)
led_pin.value(0)  # 初始状态设为熄灭
print("硬件LED初始化完成 (GPIO2)")

# 第三步：连接MQTT服务器
try:
    print(f"正在连接MQTT服务器: {MQTT_SERVER}")
    # 创建MQTT客户端实例
    client = MQTTClient(CLIENT_ID, MQTT_SERVER, port=1883)
    # 设置收到消息时的回调函数
    client.set_callback(mqtt_callback)
    # 发起连接
    client.connect()
    print("MQTT服务器连接成功！")

    # 第四步：订阅感兴趣的主题
    # 这里订阅了 'home/living_room/led' 主题，用于控制LED
    # QoS=0 表示最多送达一次，适合简单的开关控制
    subscribe_topic = b'home/living_room/led'
    client.subscribe(subscribe_topic)
    print(f"已订阅主题: {subscribe_topic.decode()}")

    # 第五步：主循环，持续监听消息
    print("进入主循环，等待控制指令...")
    print("你可以从MQTT客户端向主题 'home/living_room/led' 发送 'on', 'off', 'toggle' 消息")
    while True:
        try:
            # 非阻塞地检查是否有新消息，参数为等待时间（秒）
            # 这里等待0.5秒，如果没有消息就继续循环
            client.check_msg()
            # 你可以在这里添加其他需要周期性执行的任务
            # 例如：读取传感器数据并发布
            # current_temp = read_temperature()
            # client.publish(b'home/sensor/temp', str(current_temp).encode())
            time.sleep(0.5)
        except KeyboardInterrupt:
            # 在Thonny的Shell里按Ctrl+C可以触发这个异常，用于优雅退出
            print("用户中断，准备断开连接...")
            break
        except Exception as e:
            # 捕获其他异常，打印错误但不退出，增加鲁棒性
            print("主循环发生错误:", e)
            time.sleep(5)  # 等待一会儿再继续

except Exception as e:
    # 连接或订阅过程中的错误
    print("MQTT连接或设置失败:", e)
finally:
    # 无论是否出错，最后都尝试断开连接
    try:
        client.disconnect()
        print("MQTT连接已断开。")
    except:
        pass
    print("程序结束。")

这段代码我加入了很多注释和增强的健壮性处理，比如Wi-Fi连接的重试、更清晰的主题命名（home/living_room/led 比单纯的 ledctl 更有层次感）、更多的控制指令（toggle）、异常捕获和优雅退出机制。这些都是我在实际项目中总结出来的经验，能让你的程序更稳定。

在Thonny中，将这个文件保存到ESP32，并点击运行。如果一切配置正确，你会在Shell中看到连接成功的提示，并且ESP32的板载LED灯应该处于熄灭状态。

5. 测试与验证：从发布消息到设备响应

现在，ESP32已经在安静地等待指令了。我们怎么给它发指令呢？这就需要一个MQTT客户端工具。我推荐使用 MQTTX，它界面友好，跨平台，非常适合测试和调试。

5.1 使用MQTTX连接本地服务器

下载安装MQTTX后打开，点击界面上的“新建连接”。在连接设置里，你需要填写几个关键信息：

• 名称： 随便起，比如“我的本地EMQX”
• 服务器地址： 填写你电脑的局域网IP（就是之前记下的那个，例如 192.168.1.100），注意不是 localhost，因为MQTTX是作为一个独立客户端连接服务器。
• 端口： 1883
• 其他如用户名、密码，因为我们本地EMQX默认没有开启认证，可以先留空。

点击“连接”按钮，如果右下角状态显示“已连接”，恭喜你，客户端工具也准备好了。

5.2 发布控制消息并观察效果

在MQTTX的连接页面，你会看到一个消息发布区域。我们在这里向ESP32订阅的主题发送消息：

1. 主题： 输入 home/living_room/led （必须和ESP32代码里订阅的主题完全一致）。
2. 消息： 输入 on （注意是纯文本，不带引号）。
3. 点击右下角的发送按钮。

瞬间，你应该能看到ESP32板子上的蓝色LED灯亮起！同时，在Thonny的Shell窗口里，也会打印出 收到消息! 主题: home/living_room/led, 内容: on 和 LED已打开 的提示。

再发送一条消息，内容为 off，LED灯会熄灭。发送 toggle，LED会在亮和灭之间切换。这就是一个完整的“发布-订阅”模型：MQTTX作为发布者（Publisher），向 home/living_room/led 主题发布消息；ESP32作为订阅者（Subscriber），订阅了这个主题，所以能收到消息并执行对应的回调函数。

5.3 在EMQX控制台监控连接

此时，你可以回到EMQX的Web控制台（http://localhost:18083），刷新一下。在“客户端”页面，你应该能看到两个连接的客户端：一个是 esp32_led_controller（你的ESP32），另一个是MQTTX。点击客户端ID，还能看到更详细的信息，比如连接时间、订阅的主题等。

在“主题”页面，你能看到当前活跃的主题列表，home/living_room/led 应该在其中。这个控制台是强大的监控和调试工具，如果以后设备多了，消息复杂了，在这里可以一目了然地看到整个系统的运行状态。

6. 功能扩展：从控制LED到真正的物联网应用

能控制一个LED只是起点，基于这个框架，我们可以轻松扩展出很多实用的物联网功能。关键在于理解 “主题” 和 “消息” 这两个核心概念。主题就像是一个个频道或地址，设备可以订阅它关心的频道；消息就是通过频道传递的具体指令或数据。

6.1 实现双向通信：设备状态上报

一个完整的控制回路，不仅要有下发指令，还要有状态反馈。我们可以让ESP32在执行动作后，主动发布一条消息到另一个主题，报告自己的新状态。

修改 mqtt_callback 函数和主循环部分，在控制LED后增加状态上报：

def mqtt_callback(topic, message):
    topic_str = topic.decode('utf-8')
    msg_str = message.decode('utf-8')
    print(f'收到消息! 主题: {topic_str}, 内容: {msg_str}')

    if topic_str == 'home/living_room/led':
        current_state = led_pin.value()
        if msg_str == 'on' and current_state == 0:
            led_pin.value(1)
            # 发布状态到“状态”主题
            client.publish(b'home/living_room/led/status', b'{"state":"ON"}')
            print("LED已打开，状态已上报")
        elif msg_str == 'off' and current_state == 1:
            led_pin.value(0)
            client.publish(b'home/living_room/led/status', b'{"state":"OFF"}')
            print("LED已关闭，状态已上报")
        elif msg_str == 'toggle':
            led_pin.value(not current_state)
            new_state = "ON" if led_pin.value() else "OFF"
            client.publish(b'home/living_room/led/status', f'{{"state":"{new_state}"}}'.encode())
            print(f"LED状态翻转，新状态: {new_state}")

同时，你可以在MQTTX里再订阅 home/living_room/led/status 这个主题。这样，每次你发送控制命令后，不仅能看见LED灯变化，还能在MQTTX里立刻收到一条状态确认的JSON消息。这对于开发手机App或Web控制面板来说至关重要，保证了界面状态和设备实际状态的同步。

6.2 接入传感器：定时上报环境数据

物联网不仅仅是控制，更是感知。假设我们给ESP32接上一个DHT11温湿度传感器，就可以让它定时采集数据并上报。

首先，你需要将DHT11的数据引脚（例如接到GPIO4），并在代码中引入DHT库。然后在主循环中，每隔一段时间读取并发布数据：

import dht
import json
sensor_pin = Pin(4, Pin.IN)
dht_sensor = dht.DHT11(sensor_pin)

# 在主循环中增加数据上报
report_interval = 30  # 每30秒上报一次
last_report_time = time.time()

while True:
    client.check_msg()
    # 其他任务...

    current_time = time.time()
    if current_time - last_report_time > report_interval:
        try:
            dht_sensor.measure()
            temp = dht_sensor.temperature()
            humi = dht_sensor.humidity()
            # 构造JSON格式的消息
            sensor_data = {
                "temperature": temp,
                "humidity": humi,
                "timestamp": current_time
            }
            client.publish(b'home/living_room/sensor', json.dumps(sensor_data).encode())
            print(f"传感器数据已上报: {sensor_data}")
            last_report_time = current_time
        except Exception as e:
            print("读取传感器失败:", e)
    time.sleep(0.5)

现在，你的ESP32就变成了一个既能接受远程控制，又能主动上报环境数据的智能节点。在MQTTX订阅 home/living_room/sensor 主题，就能看到源源不断的JSON格式数据流。

6.3 利用EMQX规则引擎实现自动化

当你的设备开始发布数据后，EMQX的强大之处才真正显现。你不需要写复杂的后端逻辑，直接在EMQX控制台的“规则引擎”里，就能实现简单的自动化。

例如，你可以创建一条规则：当 home/living_room/sensor 主题上报的温度超过30度时，自动向 home/living_room/fan 主题发送一条 on 的消息，从而控制风扇打开。规则引擎支持SQL-like的语法，可以非常灵活地处理消息流，实现设备间的联动。这相当于在你的本地服务器上运行了一个轻量级的、响应极快的自动化大脑。

7. 项目优化与常见问题排查

当你成功跑通第一个demo后，可能会想把它变得更稳定、更实用。这里分享几个我踩过坑后总结的优化点和问题排查方法。

7.1 提升连接稳定性：心跳与重连机制

在实际环境中，网络并不总是稳定的。ESP32可能会偶尔Wi-Fi断连，或者MQTT服务器重启。我们的代码必须有重连的能力。一个健壮的MQTT客户端应该包含以下机制：

1. 心跳保活：在创建 MQTTClient 时，可以设置 keepalive 参数（例如60秒），客户端会定期发送PING包告诉服务器“我还活着”。
2. 循环异常检测与重连：将主循环用 try...except 包裹，一旦发现连接异常（比如 check_msg 抛出错误），就进入重连流程。
3. 独立的重连函数：把Wi-Fi连接和MQTT连接封装成一个函数，在需要时调用。

下面是一个重连逻辑的示例片段：

def reconnect():
    print('尝试重新连接...')
    time.sleep(5)  # 等待一段时间再重试
    # 先检查Wi-Fi
    if not wlan.isconnected():
        connect_wifi()
    # 再重连MQTT
    try:
        client.connect()
        client.subscribe(b'home/living_room/led')
        print('重连成功！')
        return True
    except Exception as e:
        print('重连失败:', e)
        return False

# 在主循环中
while True:
    try:
        client.check_msg()
        # ... 其他任务
        time.sleep(1)
    except OSError as e:
        # 网络或MQTT连接错误
        print('连接出错:', e)
        reconnect()
    except KeyboardInterrupt:
        break

7.2 常见问题与解决方案

• 问题：ESP32无法连接Wi-Fi。
  • 检查：SSID和密码是否正确，尤其是大小写和特殊字符。确保你的路由器是2.4GHz网络（大多数ESP32模块不支持5GHz）。在代码中打印 wlan.scan() 看看是否能扫描到你的Wi-Fi。
• 问题：ESP32能连Wi-Fi，但连不上MQTT服务器。
  • 检查：MQTT_SERVER 的IP地址是否正确。关闭电脑的防火墙（临时测试），或者为1883端口添加入站规则。在电脑上 ping 一下这个IP，确保网络可达。在EMQX控制台“监听器”页面确认1883端口正在监听 0.0.0.0。
• 问题：MQTTX能连上服务器，但ESP32连不上。
  • 检查：ESP32和你的电脑是否在同一个局域网网段（比如都是192.168.1.xxx）。如果电脑使用了VPN，有时会影响本地网络路由，暂时断开VPN试试。
• 问题：能连接，但收不到控制消息。
  • 检查：ESP32订阅的主题和MQTTX发布的主题是否完全一致，包括大小写。在EMQX控制台的“订阅”页面，查看ESP32客户端是否成功订阅了目标主题。在MQTTX发布时，可以勾选“保留消息”测试，但正式使用慎用此功能。
• 问题：程序运行一段时间后自动断开。
  • 检查：是否添加了心跳和重连机制。检查路由器是否有ARP老化时间等限制。可以尝试在EMQX客户端详情页调整“保持连接”时间。

7.3 安全加固第一步：修改默认密码

我们一直用的是EMQX的默认密码（admin/public），这在公网或共享网络环境下是极其危险的。第一步安全加固就是修改控制台密码。在EMQX控制台的“管理” -> “用户”页面，点击admin用户进行修改。更进一步，你还可以在“认证” -> “密码认证”里，为MQTT连接本身设置用户名密码，然后在ESP32的 MQTTClient 初始化时传入 user 和 password 参数，这样只有知道密码的设备才能连接你的服务器。

把上面这些步骤都走一遍，你不仅拥有了一个可远程控制的ESP32设备，更掌握了一套完整的、可扩展的本地物联网开发框架。从简单的灯控，到复杂的传感器网络和自动化场景，都可以在这个基础上搭建。最重要的是，所有数据都在你自己的掌控之中，延迟极低，响应迅速。