【雕爷学编程】MicroPython手册之 esp8266 esp32 特定端口库 esp32 模块

MicroPython是为了在嵌入式系统中运行Python 3编程语言而设计的轻量级版本解释器。与常规Python相比，MicroPython解释器体积小(仅100KB左右)，通过编译成二进制Executable文件运行，执行效率较高。它使用了轻量级的垃圾回收机制并移除了大部分Python标准库，以适应资源限制的微控制器。

MicroPython主要特点包括:
1、语法和功能与标准Python兼容,易学易用。支持Python大多数核心语法。
2、对硬件直接访问和控制,像Arduino一样控制GPIO、I2C、SPI等。
3、强大的模块系统,提供文件系统、网络、图形界面等功能。
4、支持交叉编译生成高效的原生代码,速度比解释器快10-100倍。
5、代码量少,内存占用小,适合运行在MCU和内存小的开发板上。
6、开源许可,免费使用。Shell交互环境为开发测试提供便利。
7、内置I/O驱动支持大量微控制器平台，如ESP8266、ESP32、STM32、micro:bit、掌控板和PyBoard等。有活跃的社区。

MicroPython的应用场景包括:
1、为嵌入式产品快速构建原型和用户交互。
2、制作一些小型的可 programmable 硬件项目。
3、作为教育工具,帮助初学者学习Python和物联网编程。
4、构建智能设备固件,实现高级控制和云连接。
5、各种微控制器应用如物联网、嵌入式智能、机器人等。

使用MicroPython需要注意:
1、内存和Flash空间有限。
2、解释执行效率不如C语言。
3、部分库函数与标准版有差异。
4、针对平台优化语法,订正与标准Python的差异。
5、合理使用内存资源,避免频繁分配大内存块。
6、利用原生代码提升速度关键部位的性能。
7、适当使用抽象来封装底层硬件操作。

总体来说,MicroPython让Python进入了微控制器领域，是一项重要的创新，既降低了编程门槛，又提供了良好的硬件控制能力。非常适合各类物联网和智能硬件的开发。

MicroPython的esp是指针对ESP8266和ESP32芯片的MicroPython固件和相关软件库。ESP8266和ESP32是一类广泛应用于物联网和嵌入式系统的低成本、低功耗的Wi-Fi和蓝牙模块。MicroPython的esp为这两种芯片提供了高级的脚本编程环境，使开发者能够使用Python语言进行快速原型设计和开发。

ESP8266：是一款低成本、低功耗的Wi-Fi模块/芯片，由Espressif Systems开发。它内置了TCP/IP协议栈，可以用于连接互联网，并具备较强的处理能力。MicroPython的esp提供了针对ESP8266的固件和相关软件库，使开发者可以使用MicroPython语言进行ESP8266应用的开发。

ESP32：是Espressif Systems推出的一款高度集成的Wi-Fi和蓝牙模块/芯片，与ESP8266相比，它具备更强大的处理能力、更多的外设接口和更多的内存。MicroPython的esp也提供了针对ESP32的固件和相关软件库，使开发者可以使用MicroPython语言进行ESP32应用的开发。

MicroPython的esp固件：是专门针对ESP8266和ESP32芯片的MicroPython固件版本。这些固件经过了针对性的优化，使得它们可以在ESP8266和ESP32上运行，并提供了与硬件交互、网络通信和外设控制等功能的API。

软件库：MicroPython的esp还提供了一系列与ESP8266和ESP32硬件相关的软件库，用于简化和加速开发过程。这些软件库提供了丰富的功能接口，涵盖了Wi-Fi、蓝牙、GPIO（通用输入输出）、I2C、SPI、PWM等常用的硬件和通信协议，使开发者可以方便地访问和控制硬件资源。

MicroPython 的 esp32 模块是一个专门用于控制 ESP32 芯片的功能的模块。ESP32 是一款集成了 Wi-Fi 和蓝牙功能的双核微控制器，可以用于物联网、智能家居、可穿戴设备等领域。MicroPython 是一种基于 Python 语言的嵌入式编程环境，可以让开发者用简洁高效的代码来控制硬件设备。

MicroPython 的 esp32 模块的主要特点有：

提供了一些与 ESP32 芯片相关的基本函数，例如读取内部温度传感器和霍尔传感器的值，配置睡眠模式和唤醒源，获取 ESP-IDF 堆内存的信息等。
提供了一个 Partition 类，用于访问设备闪存中的分区，并支持无线（OTA）更新的方法。分区是闪存中的逻辑区域，用于存储不同类型的数据，例如固件、配置、文件系统等。Partition 类可以查找、读写、设置引导和取消回滚分区。
提供了一个 RMT 类，用于控制 ESP32 的 RMT（Remote Control）模块。RMT 模块最初设计用于发送和接收红外遥控信号，但是由于其灵活性和精确性，它也可以用于传输或接收许多其他类型的数字信号，例如 NeoPixel 灯带、DHT 温湿度传感器等。
提供了一个 ULP 类，用于控制 ESP32 的 ULP（Ultra Low Power）协处理器。ULP 协处理器是一个独立的低功耗处理器，可以在主处理器进入深度睡眠模式时继续运行一些简单的任务，例如监测 GPIO 引脚、读取 ADC 值、操作 RTC 内存等。
提供了一些与 ESP32 芯片相关的常量，例如分区类型、唤醒级别、堆能力等。

MicroPython 的 esp32 模块的应用场景有：

物联网项目：利用 ESP32 的 Wi-Fi 和蓝牙功能，可以实现与云端或其他设备的通信，从而实现远程控制、数据采集、智能分析等功能。例如，可以使用 MicroPython 的 esp32 模块来开发一个智能温度计，通过 Wi-Fi 连接到云端服务器，并定时上传温度数据，同时可以通过手机 APP 或网页来查看历史数据或设置报警阈值。
智能家居项目：利用 ESP32 的 RMT 模块，可以实现对各种红外遥控设备的控制，从而实现智能化的家庭场景。例如，可以使用 MicroPython 的 esp32 模块来开发一个智能遥控器，通过蓝牙连接到手机 APP，并根据用户的选择来发送不同的红外信号给电视机、空调、音响等设备。
可穿戴设备项目：利用 ESP32 的 ULP 协处理器，可以实现低功耗的运行模式，从而延长电池寿命，并在必要时唤醒主处理器进行复杂的计算或通信。例如，可以使用 MicroPython 的 esp32 模块来开发一个智能手环，通过 ULP 协处理器来监测心率和步数，并在达到一定条件时通过 Wi-Fi 或蓝牙将数据发送给手机或云端。

MicroPython 的 esp32 模块的需注意事项有：

在使用 MicroPython 的 esp32 模块之前，需要先烧录 MicroPython 固件到 ESP32 芯片上，并配置好串口或网络连接，以便于上传代码或交互式操作。
在使用 MicroPython 的 esp32 模块的一些函数或类时，需要注意其参数的类型和范围，以及可能的返回值或异常，以避免出现错误或意外的结果。
在使用 MicroPython 的 esp32 模块的一些功能时，需要注意其对硬件资源的占用和影响，以及可能的兼容性或稳定性问题，以避免出现冲突或故障。

MicroPython 的 esp32 模块的几个实际运用程序案例分别是：

案例1：智能温度计：使用 ESP32 开发板、DHT11 温湿度传感器、OLED 显示屏等组件，利用 MicroPython 的 esp32 模块来实现一个智能温度计，可以通过 Wi-Fi 连接到云端服务器，并定时上传温度数据，同时可以通过手机 APP 或网页来查看历史数据或设置报警阈值。以下是
此代码由 AI 生成。仔细查看和使用。有关详细信息，请访问我们的常见问题解答。

# 导入 esp32 模块
import esp32
# 导入网络模块
import network
# 导入 DHT11 模块
import dht
# 导入 OLED 模块
import ssd1306

# 定义 Wi-Fi 名称和密码
WIFI_SSID = "your_wifi_ssid"
WIFI_PASSWORD = "your_wifi_password"

# 定义云端服务器地址和端口
SERVER_HOST = "your_server_host"
SERVER_PORT = 80

# 定义 DHT11 引脚号
DHT_PIN = 4

# 定义 OLED 引脚号和尺寸
OLED_SCL_PIN = 22
OLED_SDA_PIN = 21
OLED_WIDTH = 128
OLED_HEIGHT = 64

# 创建 Wi-Fi 对象并连接到指定的网络
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(WIFI_SSID, WIFI_PASSWORD)

# 创建 DHT11 对象并初始化
dht11 = dht.DHT11(machine.Pin(DHT_PIN))
dht11.measure()

# 创建 OLED 对象并初始化
oled = ssd1306.SSD1306_I2C(OLED_WIDTH, OLED_HEIGHT, machine.I2C(scl=machine.Pin(OLED_SCL_PIN), sda=machine.Pin(OLED_SDA_PIN)))
oled.fill(0)
oled.text("Smart Thermometer", 0, 0)
oled.show()

# 定义一个函数，用于发送温度数据到云端服务器
def send_data(temp):
    # 创建 socket 对象并连接到指定的服务器
    sock = socket.socket()
    sock.connect((SERVER_HOST, SERVER_PORT))
    # 构造 HTTP 请求头和正文
    request = "POST /data HTTP/1.1\r\n"
    request += "Host: {}\r\n".format(SERVER_HOST)
    request += "Content-Type: application/json\r\n"
    request += "Content-Length: {}\r\n".format(len(temp))
    request += "\r\n"
    request += temp + "\r\n"
    # 发送请求并关闭 socket
    sock.send(request)
    sock.close()

# 定义一个循环，用于定时读取温度数据并显示在 OLED 上，并发送到云端服务器
while True:
    # 读取温度数据并转换为字符串格式
    dht11.measure()
    temp = str(dht11.temperature())
    # 在 OLED 上显示温度数据
    oled.fill(0)
    oled.text("Smart Thermometer", 0, 0)
    oled.text("Temperature: {} C".format(temp), 0, 16)
    oled.show()
    # 发送温度数据到云端服务器
    send_data(temp)
    # 等待一段时间（单位为毫秒）
    time.sleep_ms(10000)

案例2：智能遥控器：使用 ESP32 开发板、红外发射器、红外接收器、按键等组件，利用 MicroPython 的 esp32 模块来实现一个智能遥控器，可以通过蓝牙连接到手机 APP，并根据用户的选择来发送不同的红外信号给电视机、空调、音响等设备。以下是部分代码示例：

# 导入 esp32 模块
import esp32
# 导入蓝牙模块
import bluetooth
# 导入 RMT 模块
from machine import RMT

# 定义蓝牙名称和服务 UUID（通用唯一标识符）
BT_NAME = "Smart Remote"
BT_UUID = bluetooth.UUID("00001101-0000-1000-8000-00805F9B34FB")

# 定义红外发射器引脚号和频率
IR_TX_PIN = 5
IR_FREQ = 38000

# 定义红开关机按键引脚号和红外编码
POWER_BTN_PIN = 0
POWER_IR_CODE = [9000, 4500, 600, 550, 600, 550, 600, 550, 600, 1650, 600, 1650, 600, 1650, 600, 550, 600, 550, 600, 550, 600, 1650, 600, 1650, 600, 1650, 600, 550, 600, 550, 600, 550, 600, 1650, 600]

# 创建蓝牙对象并初始化
bt = bluetooth.Bluetooth()
bt.active(True)
bt.config(name=BT_NAME)

# 创建 RMT 对象并初始化
rmt = RMT(0, pin=IR_TX_PIN)

# 定义一个函数，用于将红外编码转换为 RMT 脉冲序列
def ir_code_to_rmt(code):
    # 创建一个空列表
    pulses = []
    # 遍历红外编码中的每个值
    for val in code:
        # 将值除以 RMT 的时钟周期（80 ns）
        val = val // (1000000 // rmt.source_freq())
        # 将值添加到脉冲序列中，分别表示高电平和低电平的持续时间
        pulses.append(val)
        pulses.append(val)
    # 返回脉冲序列
    return pulses

# 定义一个函数，用于发送红外信号
def send_ir(code):
    # 将红外编码转换为 RMT 脉冲序列
    pulses = ir_code_to_rmt(code)
    # 设置 RMT 的载波频率和占空比
    rmt.carrier_freq(IR_FREQ)
    rmt.carrier_duty(50)
    # 发送 RMT 脉冲序列
    rmt.write_pulses(pulses)

# 定义一个函数，用于处理蓝牙连接的回调事件
def bt_callback(event):
    # 如果事件是连接建立
    if event == bluetooth.SERVER_CONNECTED:
        # 打印连接成功的信息
        print("Bluetooth connected")
    # 如果事件是连接断开
    elif event == bluetooth.SERVER_DISCONNECTED:
        # 打印连接断开的信息
        print("Bluetooth disconnected")

# 定义一个函数，用于处理蓝牙数据的回调事件
def bt_data_callback(data):
    # 打印接收到的数据
    print("Bluetooth data received:", data)
    # 如果数据是 "power"，则发送开关机红外信号
    if data == "power":
        send_ir(POWER_IR_CODE)

# 注册蓝牙连接的回调函数
bt.callback(bt_callback)
# 注册蓝牙数据的回调函数
bt.data_callback(bt_data_callback)
# 启动蓝牙服务，并指定服务 UUID 和最大连接数（1）
bt.start_service(BT_UUID, max_connections=1)

# 创建开关机按键对象并初始化，设置为上拉输入模式，并注册中断回调函数，触发方式为下降沿（按下）
power_btn = machine.Pin(POWER_BTN_PIN, machine.Pin.IN, machine.Pin.PULL_UP)
power_btn.irq(lambda pin: send_ir(POWER_IR_CODE), trigger=machine.Pin.IRQ_FALLING)

# 定义一个循环，用于保持程序运行
while True:
    pass

案例3：智能手环：使用 ESP32 开发板、心率传感器、OLED 显示屏、电池等组件，利用 MicroPython 的 esp32 模块来实现一个智能手环，可以通过 ULP 协处理器来监测心率和步数，并在达到一定条件时通过 Wi-Fi 或蓝牙将数据发送给手机或云端。以下是部分代码示例：

# 导入 esp32 模块
import esp32
# 导入网络模块
import network
# 导入 ULP 模块
import machine, ulp

# 定义 Wi-Fi 名称和密码
WIFI_SSID = "your_wifi_ssid"
WIFI_PASSWORD = "your_wifi_password"

# 定义云端服务器地址和端口
SERVER_HOST = "your_server_host"
SERVER_PORT = 80

# 定义心率传感器引脚号和阈值
HR_PIN = 36
HR_THRESHOLD = 500

# 定义 OLED 引脚号和尺寸
OLED_SCL_PIN = 22
OLED_SDA_PIN = 21
OLED_WIDTH = 128
OLED_HEIGHT = 64

# 定义 ULP 程序的内存地址和大小
ULP_MEM_ADDR = 0x50000000
ULP_MEM_SIZE = 8192

# 创建 Wi-Fi 对象并连接到指定的网络
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(WIFI_SSID, WIFI_PASSWORD)

# 创建 OLED 对象并初始化
oled = ssd1306.SSD1306_I2C(OLED_WIDTH, OLED_HEIGHT, machine.I2C(scl=machine.Pin(OLED_SCL_PIN), sda=machine.Pin(OLED_SDA_PIN)))
oled.fill(0)
oled.text("Smart Bracelet", 0, 0)
oled.show()

# 定义一个函数，用于发送心率和步数数据到云端服务器
def send_data(hr, steps):
    # 创建 socket 对象并连接到指定的服务器
    sock = socket.socket()
    sock.connect((SERVER_HOST, SERVER_PORT))
    # 构造 HTTP 请求头和正文，将心率和步数数据转换为 JSON 格式
    request = "POST /data HTTP/1.1\r\n"
    request += "Host: {}\r\n".format(SERVER_HOST)
    request += "Content-Type: application/json\r\n"
    data = {"heart_rate": hr, "steps": steps}
    data = json.dumps(data)
    request += "Content-Length: {}\r\n".format(len(data))
    request += "\r\n"
    request += data + "\r\n"
    # 发送请求并关闭 socket
    sock.send(request)
    sock.close()

# 定义一个函数，用于编译 ULP 程序并加载到内存中
def load_ulp():
    # 创建 ULP 对象并设置内存地址和大小
    ulp = machine.ULP()
    ulp.set_wakeup_period(0, 5000) # 设置唤醒周期为 5 秒
    ulp.set_memory_address(ULP_MEM_ADDR, ULP_MEM_SIZE)

    # 编写 ULP 程序的汇编代码，用于监测心率传感器的信号和计算步数
    asm_code = """
        .set adc_channel, 0 # 设置 ADC 通道为 0（对应 GPIO36）
        .set threshold, {} # 设置心率信号的阈值为 {}
        .set rtc_counter_index, 64 # 设置 RTC 计数器的索引为 64（对应 RTC 内存地址 0x50000080）
        .set rtc_heart_rate_index, 65 # 设置 RTC 心率值的索引为 65（对应 RTC 内存地址 0x50000084）
        .set rtc_steps_index, 66 # 设置 RTC 步数值的索引为 66（对应 RTC 内存地址 0x50000088）
        .set rtc_flag_index, 67 # 设置 RTC 标志位的索引为 67（对应 RTC 内存地址 0x5000008C）

        .bss
        counter: .long 1 # 定义一个变量 counter，用于记录心率信号的上升沿次数

        .text

        entry: # 程序入口点

        # 增加计数器的值，并将其写入 RTC 内存中，用于记录运行时间
        move r3, rtc_counter_index 
        ld r2, r3, 0 
        add r2, r2, 1 
        st r2, r3, 0 

        # 检测心率传感器的信号，如果大于阈值，则认为是一个上升沿
        adc r0, adc_channel, 0 
        move r1, threshold 
        bge r0, r1, high 

        # 如果不是上升沿，则跳转到 end
        jump end 

        high: # 如果是上升沿，则执行以下操作

        # 增加 counter 的值，并将其写入 RTC 内存中，用于记录心率信号的上升沿次数
        ld r2, counter, 0 
        add r2, r2, 1 
        st r2, counter, 0 
        move r3, rtc_heart_rate_index 
        st r2, r3, 0 

        # 如果 counter 的值等于 10，则认为是一个心跳周期，计算心率值，并清零 counter
        move r1, 10 
        beq r2, r1, beat 

        # 如果不是心跳周期，则跳转到 end
        jump end 

        beat: # 如果是心跳周期，则执行以下操作

        # 计算心率值，公式为：心率 = 60 / (计数器 * 周期)，其中周期为 5 秒
        move r0, 60 
        move r1, rtc_counter_index 
        ld r2, r1, 0 
        mul r2, r2, 5 
        div r0, r0, r2 
        st r0, counter, 0 # 将心率值写入 counter 中，用于显示在 OLED 上
        move r3, rtc_heart_rate_index 
        st r0, r3, 0 # 将心率值写入 RTC 内存中，用于发送到云端

        # 清零计数器的值
        move r0, 0 
        st r0, rtc_counter_index 

        # 增加步数值，并将其写入 RTC 内存中，用于显示和发送
        move r3, rtc_steps_index 
        ld r2, r3, 0 
        add r2, r2, 1 
        st r2, r3, 0 

        # 设置标志位为 1，并将其写入 RTC 内存中，用于唤醒主处理器
        move r3, rtc_flag_index 
        move r2, 1 
        st r2, r3, 0 

        end: # 程序结束点

        halt # 暂停 ULP 协处理器，等待下一次唤醒
    """.format(HR_THRESHOLD)

    # 编译 ULP 程序并加载到内存中
    ulp.load_assembly(asm_code)
    ulp.run(ULP_MEM_ADDR)

# 定义一个函数，用于读取 RTC 内存中的数据，并显示在 OLED 上，并发送到云端
def read_data():
    # 创建 RTC 对象并初始化
    rtc = machine.RTC()
    rtc.init()

    # 获取 RTC 内存中的计数器、心率、步数和标志位的值
    counter = rtc.memory(64)
    heart_rate = rtc.memory(65)
    steps = rtc.memory(66)
    flag = rtc.memory(67)

    # 在 OLED 上显示心率和步数的值
    oled.fill(0)
    oled.text("Smart Bracelet", 0 ,0)
    oled.text("Heart Rate: {} bpm".format(heart_rate), 0 ,16)
    oled.text("Steps: {}".format(steps), 0 ,32)
    oled.show()

    # 如果标志位为 1，则表示有新的数据需要发送到云端
    if flag == 1:
        # 发送心率和步数数据到云端服务器
        send_data(heart_rate, steps)
        
# 调用 load_ulp 函数，编译 ULP 程序并加载到内存中
load_ulp()

# 定义一个循环，用于检测 ULP 协处理器是否唤醒了主处理器，并读取 RTC 内存中的数据
while True:
    # 检测 ULP 协处理器是否唤醒了主处理器，如果是，则调用 read_data 函数
    if machine.wake_reason() == machine.ULP

案例4：控制LED灯：

import machine
import time

led_pin = machine.Pin(2, machine.Pin.OUT)  # 设置GPIO2为输出引脚

while True:
    led_pin.on()   # 打开LED
    time.sleep(1)  # 等待1秒
    led_pin.off()  # 关闭LED
    time.sleep(1)  # 等待1秒

在这个示例中，我们使用`machine`模块来控制esp32上的GPIO引脚。我们将GPIO2配置为输出引脚，并使用`Pin`类初始化一个Pin对象。然后，我们使用`on()`和`off()`方法控制LED的开关状态，通过`time.sleep()`函数在LED打开和关闭之间插入延迟，从而创建LED闪烁的效果。

案例5：读取温湿度传感器数据：

```python
import machine
import dht

dht_pin = machine.Pin(4, machine.Pin.IN)          # 设置GPIO4为输入引脚
dht_sensor = dht.DHT11(machine.Pin(4))             # 创建DHT11对象

while True:
    dht_sensor.measure()                           # 测量温湿度
    temperature = dht_sensor.temperature()         # 获取温度值
    humidity = dht_sensor.humidity()               # 获取湿度值
    print("Temperature: {}°C, Humidity: {}%".format(temperature, humidity))
    time.sleep(2)

在这个示例中，我们使用machine模块和dht模块来读取DHT11温湿度传感器的数据。我们将GPIO4配置为输入引脚，并使用Pin类初始化一个Pin对象。然后，我们创建一个DHT11对象，并使用measure()方法测量温湿度。通过temperature()和humidity()方法获取温度和湿度值，并将其打印输出。最后，使用time.sleep()函数添加延迟以控制采样频率。

案例6：连接Wi-Fi网络：

import network

ssid = "your_wifi_ssid"
password = "your_wifi_password"

wlan = network.WLAN(network.STA_IF)                # 创建Wi-Fi客户端对象
wlan.active(True)                                  # 激活Wi-Fi
wlan.connect(ssid, password)                       # 连接Wi-Fi网络

while not wlan.isconnected():
    pass

print("Connected to Wi-Fi")
print("IP address:", wlan.ifconfig()[0])

在这个示例中，我们使用`network`模块连接esp32到Wi-Fi网络。我们提供Wi-Fi的SSID和密码，并使用`WLAN`类创建一个Wi-Fi客户端对象。然后，我们使用`active(True)`方法激活Wi-Fi，并使用`connect()`方法连接到指定的Wi-Fi网络。通过循环等待Wi-Fi连接成功，使用`isconnected()`方法进行检查。一旦连接成功，我们打印输出连接成功的信息以及分配给esp32的IP地址。这些示例展示了esp32在MicroPython中的实际应用。通过控制IO引脚、读取传感器数据和连接到Wi-Fi网络，esp32可以用于各种物联网（IoT）项目和嵌入式应用。

案例7：控制LED灯

在这个例子中，我们将会使用ESP32的某个引脚来控制一个LED灯。

```python
from machine import Pin
import time

led = Pin(2, Pin.OUT)  # 创建一个引脚对象，GPIO2连接了一个LED灯

while True:
    led.value(not led.value())  # 切换LED灯的状态
    time.sleep(0.5)  # 等待0.5秒

示例8：读取温度传感器

在这个例子中，我们将会使用ESP32的I2C接口来读取一个温度传感器（例如BMP180）的数据。

from machine import I2C, Pin
import bmp180

i2c = I2C(scl=Pin(5), sda=Pin(4))  # 创建一个I2C对象
sensor = bmp180.BMP180(i2c)  # 创建一个BMP180传感器对象
sensor.oversample_sett = 2
sensor.baseline = 101325

temp = sensor.temperature  # 读取温度
print('Temperature:', temp)

示例9：连接Wi-Fi网络

在这个例子中，我们将会使用ESP32的Wi-Fi功能来连接一个Wi-Fi网络。

import network

sta_if = network.WLAN(network.STA_IF)  # 创建一个WLAN对象
sta_if.active(True)  # 激活WLAN
sta_if.connect('<your ESSID>', '<your password>')  # 连接Wi-Fi网络

while not sta_if.isconnected():  # 等待直到连接成功
    pass

print('Connected to Wi-Fi network:', sta_if.ifconfig())

以上代码需要替换和为实际的Wi-Fi网络名和密码。