MicroPython es una versión ligera del intérprete diseñada para ejecutar el lenguaje de programación Python 3 en sistemas integrados. En comparación con Python normal, el intérprete de MicroPython es pequeño (solo alrededor de 100 KB) y se compila en un archivo ejecutable binario para su ejecución, lo que resulta en una mayor eficiencia de ejecución. Utiliza un mecanismo de recolección de basura liviano y elimina la mayor parte de la biblioteca estándar de Python para adaptarse a microcontroladores con recursos limitados.
Las características principales de MicroPython incluyen:
1. La sintaxis y las funciones son compatibles con Python estándar, lo que facilita su aprendizaje y uso. Admite la mayor parte de la sintaxis principal de Python.
2. Acceda y controle directamente el hardware, controle GPIO, I2C, SPI, etc. como Arduino.
3. Potente sistema de módulos, que proporciona sistema de archivos, red, interfaz gráfica y otras funciones.
4. Admite compilación cruzada para generar código nativo eficiente, que es entre 10 y 100 veces más rápido que el intérprete.
5. La cantidad de código es pequeña y el uso de memoria es pequeño, adecuado para ejecutarse en MCU y placas de desarrollo con poca memoria.
6. Licencia de código abierto, de uso gratuito. El entorno interactivo de Shell proporciona comodidad para el desarrollo y las pruebas.
7. El controlador de E/S incorporado admite una gran cantidad de plataformas de microcontroladores, como ESP8266, ESP32, STM32, micro:bit, placa de control y PyBoard, etc. Hay una comunidad activa.
Los escenarios de aplicación de MicroPython incluyen:
1. Crear rápidamente prototipos e interacciones de usuario para productos integrados.
2. Realice algunos pequeños proyectos de hardware programables.
3. Como herramienta educativa, ayuda a los principiantes a aprender programación en Python e IoT.
4. Cree firmware para dispositivos inteligentes para lograr control avanzado y conectividad en la nube.
5. Diversas aplicaciones de microcontroladores como Internet de las cosas, inteligencia integrada, robots, etc.
Cosas a tener en cuenta al utilizar MicroPython:
1. La memoria y el espacio Flash son limitados.
2. La eficiencia de explicación y ejecución no es tan buena como la del lenguaje C.
3. Algunas funciones de la biblioteca son diferentes a las de la versión estándar.
4. Optimice la sintaxis de la plataforma y corrija las diferencias con Python estándar.
5. Utilice los recursos de memoria de forma racional y evite asignar grandes bloques de memoria con frecuencia.
6. Utilice código nativo para mejorar el rendimiento de las piezas críticas para la velocidad.
7. Utilice la abstracción de forma adecuada para encapsular las operaciones de hardware subyacentes.
En términos generales, MicroPython lleva Python al campo de los microcontroladores, lo cual es una innovación importante que no solo reduce el umbral de programación sino que también proporciona buenas capacidades de control de hardware. Es muy adecuado para el desarrollo de varios tipos de Internet de las cosas y hardware inteligente.
El esp de MicroPython se refiere al firmware de MicroPython y las bibliotecas de software relacionadas para los chips ESP8266 y ESP32. ESP8266 y ESP32 son una clase de módulos Wi-Fi y Bluetooth de bajo costo y bajo consumo ampliamente utilizados en IoT y sistemas integrados. El esp de MicroPython proporciona un entorno de secuencias de comandos avanzado para ambos chips, lo que permite a los desarrolladores utilizar el lenguaje Python para la creación y el desarrollo rápidos de prototipos.
ESP8266: Es un módulo/chip Wi-Fi de bajo costo y bajo consumo desarrollado por Espressif Systems. Tiene una pila de protocolos TCP/IP incorporada, se puede utilizar para conectarse a Internet y tiene sólidas capacidades de procesamiento. El esp de MicroPython proporciona firmware y bibliotecas de software relacionadas para ESP8266, lo que permite a los desarrolladores utilizar el lenguaje MicroPython para desarrollar aplicaciones ESP8266.
ESP32: Es un módulo/chip Wi-Fi y Bluetooth altamente integrado lanzado por Espressif Systems, en comparación con ESP8266, tiene una potencia de procesamiento más potente, más interfaces periféricas y más memoria. El esp de MicroPython también proporciona firmware y bibliotecas de software relacionadas para ESP32, lo que permite a los desarrolladores utilizar el lenguaje MicroPython para desarrollar aplicaciones ESP32.
Firmware esp de MicroPython: es una versión de firmware de MicroPython específica para chips ESP8266 y ESP32. Estos firmwares se han optimizado específicamente para ejecutarse en ESP8266 y ESP32 y proporcionan API para interacción de hardware, comunicación de red y control de periféricos.
Bibliotecas de software: el esp de MicroPython también proporciona una serie de bibliotecas de software relacionadas con el hardware ESP8266 y ESP32 para simplificar y acelerar el proceso de desarrollo. Estas bibliotecas de software proporcionan un amplio conjunto de interfaces funcionales, que cubren hardware y protocolos de comunicación de uso común, como Wi-Fi, Bluetooth, GPIO (entrada y salida de uso general), I2C, SPI y PWM, lo que permite a los desarrolladores acceder y controlar fácilmente el hardware. recursos.
Esp32.ULP.set_wakeup_period() de MicroPython es un método utilizado para establecer el período para que el coprocesador ULP (Ultra Low-Power) active la CPU principal. Tiene las siguientes características principales, escenarios de aplicación y precauciones:
caracteristica principal:
esp32.ULP.set_wakeup_period() es un método de la clase esp32.ULP, que puede actuar sobre cualquier objeto coprocesador ULP.
La función de esp32.ULP.set_wakeup_period() es establecer cuánto tiempo espera el coprocesador ULP después de ejecutar un programa antes de activar la CPU principal.
El valor de retorno de esp32.ULP.set_wakeup_period() es Ninguno, lo que indica que la configuración se realizó correctamente.
Hay dos parámetros para esp32.ULP.set_wakeup_period(): el primero es un número entero, que indica el índice del período de activación, que va de 0 a 412. El segundo es un número entero que representa el número de microsegundos en el período de activación, que oscila entre 0 y 4294967295.
Los parámetros predeterminados de esp32.ULP.set_wakeup_period() son 0 y 0, lo que significa que no se activa la CPU principal.
Escenarios de aplicación:
La función de esp32.ULP.set_wakeup_period() se puede utilizar para activar periódicamente la CPU principal en el modo de bajo consumo de ESP32 y realizar algunas tareas que deben realizarse de forma regular o periódica, como monitorear sensores, controlar periféricos, actualizar datos, etc
La función de esp32.ULP.set_wakeup_period() se puede usar en el modo de trabajo normal de ESP32 para permitir que el coprocesador ULP despierte la CPU principal después de un cierto período de tiempo para realizar algunas tareas que deben retrasarse o programarse. como enviar solicitudes de red y mostrar resultados, guardar datos, etc.
La función de esp32.ULP.set_wakeup_period() también se puede usar en el modo de suspensión profunda de ESP32 para permitir que el coprocesador ULP despierte la CPU principal después de un cierto período de tiempo para realizar algunas tareas que requieren baja frecuencia o baja energía. consumo, como verificar el nivel de la batería, el tiempo de sincronización, actualizar el firmware y más.
Precauciones:
La función de esp32.ULP.set_wakeup_period() debe prestar atención a los conflictos con otras funciones que ocupan coprocesadores o pines ULP, como SPI, I2C, UART, etc.
La función de esp32.ULP.set_wakeup_period() debe prestar atención al impacto de otras funciones que ocupan memoria compartida o interrumpen señales, como comunicación de red, sistema de archivos, recolección de basura, etc.
La función de esp32.ULP.set_wakeup_period() debe coordinarse con otras funciones que requieren servicios de interrupción o servicios de temporizador, como temporizadores de máquina, interrupciones de máquina, etc.
Los siguientes son varios ejemplos de aplicaciones prácticas que utilizan el método esp32.ULP.set_wakeup_period() de MicroPython:
Caso 1: use esp32.ULP.set_wakeup_period() para configurar el coprocesador ULP para que active la CPU principal cada 10 segundos e imprima la hora actual.
# 导入必要的模块
import esp32
import machine
import time
# 定义一个空程序的源代码，使用esp32_ulp提供的汇编语法
empty_src = """
entry: halt # 停止执行
"""
# 使用esp32_ulp.assemble()函数来编译源代码，并返回一个字节对象
empty_bin = esp32_ulp.assemble(empty_src)
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为10秒
esp32.ULP.set_wakeup_period(0, 10000000)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, empty_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 定义一个循环，每次被唤醒后打印出当前时间，并让主CPU重新进入睡眠模式
while True:
# 使用time.localtime()函数来获取当前时间，返回一个元组
t = time.localtime()
# 使用print()函数来打印出当前时间，格式为年-月-日 时:分:秒
print('%d-%02d-%02d %02d:%02d:%02d' % t[:6])
# 使用machine.lightsleep()函数来让主CPU进入轻度睡眠模式，等待下一次唤醒
machine.lightsleep()
Caso 2: use esp32.ULP.set_wakeup_period() para configurar el coprocesador ULP para que demore 5 segundos antes de activar la CPU principal después de ejecutar un programa y controlar el parpadeo de una luz LED.
# 导入必要的模块
import esp32
import machine
# 定义一个控制LED灯的程序的源代码，使用py-esp32-ulp提供的汇编语法
led_src = """
data: .long 0
entry: move r3, data # 将数据地址存入r3寄存器
load r0, r3, 0 # 将数据值加载到r0寄存器
move r1, 18 # 将引脚号18存入r1寄存器
i2c_rd r2, r1, 28, 1 # 读取GPIO_OUT寄存器的值，存入r2寄存器
xor r2, r2, r0 # 将r2和r0做异或运算，得到反转后的值，存入r2寄存器
i2c_wr r2, r1, 28, 1 # 将r2的值写入GPIO_OUT寄存器，控制LED灯的状态
store r2, r3, 0 # 将r2的值存回数据地址，更新数据值
halt # 停止执行
"""
# 使用py_esp32_ulp.assemble()函数来编译源代码，并返回一个字节对象
led_bin = py_esp32_ulp.assemble(led_src)
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为5秒
esp32.ULP.set_wakeup_period(0, 5000000)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, led_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 创建一个Pin对象，绑定到第18号引脚，设置为输出模式，并初始化为低电平（关闭LED灯）
led = machine.Pin(18, machine.Pin.OUT)
led.value(0)
# 此时，ESP32的第18号引脚会每隔5秒反转一次电平，从而控制LED灯的闪烁
Caso 3: use esp32.ULP.set_wakeup_period() para configurar el coprocesador ULP para que espere una interrupción externa antes de activar la CPU principal después de ejecutar un programa y leer el estado de un botón.
# 导入必要的模块
import esp32
import machine
# 定义一个读取按钮的程序的源代码，使用binutils-esp32ulp编译生成，保存在ESP32的文件系统中，文件名为button.bin
# 使用open()函数来打开二进制文件，并读取其内容，返回一个字节对象
with open('button.bin', 'rb') as f:
button_bin = f.read()
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为-1，表示等待一个外部中断再唤醒主CPU
esp32.ULP.set_wakeup_period(-1)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, button_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 创建一个Pin对象，绑定到第19号引脚，设置为输入模式，并启用内部上拉电阻
button = machine.Pin(19, machine.Pin.IN, machine.Pin.PULL_UP)
# 定义一个中断处理函数，用于唤醒ULP协处理器
def wake_ulp(pin):
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为0，表示立即唤醒
esp32.ULP.set_wakeup_period(0)
# 使用Pin对象的irq()方法来设置中断触发模式为下降沿，并绑定中断处理函数
button.irq(trigger=machine.Pin.IRQ_FALLING, handler=wake_ulp)
# 定义一个循环，每次被唤醒后读取共享内存中的数据，并打印出按钮的状态
while True:
# 使用esp32.ULP.mem_read()函数来读取共享内存中的数据，地址为0，返回一个整数
button_state = esp32.ULP.mem_read(0)
# 判断按钮的状态是按下还是松开，并打印出结果
if button_state == 0:
print('Button is pressed')
else:
print('Button is released')
# 使用machine.lightsleep()函数来让主CPU进入轻度睡眠模式，等待下一次唤醒
machine.lightsleep()
Caso 4: Establecer un período de activación de bajo consumo de energía:
import esp32
esp32.ULP.set_wakeup_period(5000) # every 5 seconds
Caso 5: Establecer diferentes ciclos para despertar repetidamente:
import esp32, math
for i in range(5):
esp32.ULP.set_wakeup_period(int(2000*math.sin(i)+3000))
Caso 6: Borrar la configuración del ciclo de despertador:
import esp32
esp32.ULP.set_wakeup_period(0)
El primer ejemplo establece un período fijo de activación de 5 segundos. El segundo ejemplo configura diferentes ciclos aleatorios para despertar. El tercer ejemplo borra la configuración del ciclo de despertador anterior. Esta función se utiliza para configurar el ciclo de activación regular del coprocesador ULP, que desempeña un papel en la gestión del bajo consumo de energía. La estrategia de activación se puede configurar de manera flexible a través de parámetros como administrador y frecuencia.
Caso 7: establezca el período de activación del coprocesador ULP en 1 segundo:
import esp32
# 定义 ULP 程序
ulp_program = esp32.ULP()
# 设置 ULP 协处理器的唤醒周期为 1 秒
ulp_program.set_wakeup_period(1)
Este programa de muestra muestra cómo utilizar el método set_wakeup_period() para configurar el período de activación del coprocesador ULP en 1 segundo.
Caso 8: establezca el período de activación del coprocesador ULP en 500 milisegundos:
import esp32
# 定义 ULP 程序
ulp_program = esp32.ULP()
# 设置 ULP 协处理器的唤醒周期为 500 毫秒
ulp_program.set_wakeup_period(0.5)
Este programa de muestra muestra cómo utilizar el método set_wakeup_period() para configurar el período de activación del coprocesador ULP en 500 milisegundos.
Caso 9: Establecer dinámicamente el ciclo de activación del coprocesador ULP:
import esp32
import time
# 定义 ULP 程序
ulp_program = esp32.ULP()
# 设置 ULP 协处理器的初始唤醒周期为 1 秒
ulp_program.set_wakeup_period(1)
# 等待一段时间
time.sleep(5)
# 动态调整 ULP 协处理器的唤醒周期为 500 毫秒
ulp_program.set_wakeup_period(0.5)
Este programa de muestra muestra cómo ajustar dinámicamente el período de activación del coprocesador ULP durante el tiempo de ejecución. Comience configurando el período de activación en 1 segundo, luego espere 5 segundos antes de ajustarlo a 500 milisegundos.
Estos programas de muestra muestran cómo configurar el período de activación del coprocesador ULP del ESP32 usando el método esp32.ULP.set_wakeup_period(). Al ajustar el período de activación, puede controlar el tiempo de ejecución y el consumo de energía del coprocesador ULP para satisfacer necesidades y escenarios de aplicación específicos. Tenga en cuenta que la unidad del período de despertar es segundos y puede usar decimales para expresar milisegundos.
