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.load_binary() de MicroPython es un método utilizado para cargar archivos binarios en la memoria del coprocesador ULP (Ultra Low-Power). Tiene las siguientes características principales, escenarios de aplicación y precauciones:
caracteristica principal:
esp32.ULP.load_binary() es un método de la clase esp32.ULP, que puede actuar sobre cualquier objeto coprocesador ULP.
La función de esp32.ULP.load_binary() es cargar un objeto de byte, es decir, un archivo binario que contiene código de máquina ULP, en la dirección especificada en la memoria del coprocesador ULP.
El valor de retorno de esp32.ULP.load_binary() es Ninguno, lo que indica que la carga se realizó correctamente.
Hay dos parámetros para esp32.ULP.load_binary (), el primero es un número entero, que indica la dirección de carga, que va de 0 a 409512. El segundo es un objeto de bytes que representa el archivo binario que se va a cargar.
Los parámetros predeterminados de esp32.ULP.load_binary() son 0 y un objeto de byte nulo, lo que significa que no se carga nada.
Escenarios de aplicación:
La función esp32.ULP.load_binary() se puede utilizar para compilar o descargar el ensamblador ULP directamente en el ESP32 y cargarlo en la memoria del coprocesador ULP, listo para ejecutarse.
La función de esp32.ULP.load_binary() se puede utilizar para modificar o reemplazar dinámicamente el programa en la memoria del coprocesador ULP en ESP32 para implementar diferentes funciones o lógica.
La función esp32.ULP.load_binary() también se puede utilizar para guardar o restaurar programas en la memoria del coprocesador ULP en ESP32 para lograr persistencia o copia de seguridad.
Precauciones:
La función de esp32.ULP.load_binary() 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.load_binary() 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.load_binary() 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.load_binary() de MicroPython:
Caso 1: use esp32.ULP.load_binary () para cargar un archivo binario compilado por py-esp32-ulp. Este archivo implementa una función de contador simple y almacena el resultado en la memoria compartida.
# 导入必要的模块
import esp32
import machine
import py_esp32_ulp
# 定义一个计数器程序的源代码，使用py-esp32-ulp提供的汇编语法
counter_src = """
data: .long 0
entry: move r3, data
loop: add r3, r3, 1
move r0, r3
store r0, r3, 0
wait 1000
jump loop
"""
# 使用py_esp32_ulp.assemble()函数来编译源代码，并返回一个字节对象
counter_bin = py_esp32_ulp.assemble(counter_src)
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为0，表示不唤醒主CPU
esp32.ULP.set_wakeup_period(0)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, counter_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 使用machine.deepsleep()函数来让主CPU进入深度睡眠模式，ULP协处理器继续运行
machine.deepsleep()
# 使用esp32.ULP.mem_read()函数来读取共享内存中的数据，地址为0，返回一个整数
counter = esp32.ULP.mem_read(0)
# 打印出计数器的值
print(counter)
Caso 2: use esp32.ULP.load_binary() para cargar un archivo binario compilado por micropython-esp32-ulp. Este archivo implementa una función de sensor de temperatura simple y almacena el resultado en la memoria compartida.
# 导入必要的模块
import esp32
import machine
import esp32_ulp
# 定义一个温度传感器程序的源代码，使用esp32_ulp提供的汇编语法
temp_src = """
data: .long 0
entry: tsens r0, 850 # 读取温度传感器的值，延迟850个周期
move r3, data # 将数据地址存入r3寄存器
store r0, r3, 0 # 将温度值存入数据地址
halt # 停止执行
"""
# 使用esp32_ulp.assemble()函数来编译源代码，并返回一个字节对象
temp_bin = esp32_ulp.assemble(temp_src)
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为1000000，表示每隔1秒唤醒一次主CPU
esp32.ULP.set_wakeup_period(0, 1000000)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, temp_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 定义一个循环，每隔1秒打印出温度值，并让主CPU重新进入睡眠模式
while True:
# 使用esp32.ULP.mem_read()函数来读取共享内存中的数据，地址为0，返回一个整数
temp = esp32.ULP.mem_read(0)
# 打印出温度值，单位为摄氏度
print(temp / 2 - 40)
# 使用machine.lightsleep()函数来让主CPU进入轻度睡眠模式，等待下一次唤醒
machine.lightsleep()
Caso 3: use esp32.ULP.load_binary () para cargar un archivo binario compilado por binutils-esp32ulp. Este archivo implementa una función PWM (modulación de ancho de pulso) simple y envía el resultado al pin.
# 导入必要的模块
import esp32
import machine
import py_esp32_ulp
# 定义一个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的值存回数据地址，更新数据值
wait 1000000 # 等待1000000个周期（约为1秒）
jump entry # 跳转到entry标签，重复执行
"""
# 使用py_esp32_ulp.assemble()函数来编译源代码，并返回一个字节对象
led_bin = py_esp32_ulp.assemble(led_src)
# 使用esp32.ULP.set_wakeup_period()函数来设置ULP协处理器唤醒周期为0，表示不唤醒主CPU
esp32.ULP.set_wakeup_period(0)
# 使用esp32.ULP.load_binary()函数来加载二进制文件到ULP协处理器内存中，起始地址为0
esp32.ULP.load_binary(0, led_bin)
# 使用esp32.ULP.run()函数来运行二进制文件，起始地址为0
esp32.ULP.run(0)
# 此时，ESP32的第18号引脚会每隔1秒反转一次电平，从而控制LED灯的闪烁
Caso 4: Cargar código binario del programa ULP:
import esp32
with open('ulp_code.bin', 'rb') as f:
bin_data = f.read()
esp32.ULP.load_binary(bin_data)
Caso 5: Lectura del código ULP desde Flash y carga:
import esp32
buf = esp32.flash_read(addr, size)
esp32.ULP.load_binary(buf)
Caso 6: Eliminar el programa ULP cargado:
import esp32
esp32.ULP.load_binary(b'')
El primer ejemplo lee datos binarios de un archivo y los carga en un ULP. El segundo ejemplo carga código ULP desde Flash. El tercer ejemplo borra un programa ULP previamente cargado. Esta función se utiliza para cargar código binario ULP precompilado. A través de él, se puede lograr la carga dinámica de programas ULP, que a menudo se utiliza en escenarios de actualización de firmware. Al cooperar con la lectura y escritura Flash, se puede lograr una gestión flexible de los programas ULP.
Caso 7: Cargar el código binario del programa ULP:
import esp32
# 定义 ULP 程序的二进制代码
ulp_binary_code = b'\x00\x00\x00\x00\x00\x00\x00\x00' # 请替换为实际的二进制代码
# 加载 ULP 程序的二进制代码到 ULP 协处理器
esp32.ULP.load_binary(ulp_binary_code)
Este programa de muestra muestra cómo utilizar el método load_binary() para cargar el código binario de un programa ULP en el coprocesador ULP.
Caso 8: Cargar el código binario del programa ULP desde un archivo:
import esp32
# 从文件中读取 ULP 程序的二进制代码
with open('ulp_program.bin', 'rb') as file:
ulp_binary_code = file.read()
# 加载 ULP 程序的二进制代码到 ULP 协处理器
esp32.ULP.load_binary(ulp_binary_code)
Este programa de muestra muestra cómo leer el código binario de un programa ULP desde un archivo y cargarlo en el coprocesador ULP usando el método load_binary(). Asegúrese de reemplazar la ruta del archivo de código binario real con "ulp_program.bin".
Caso 9: Utilice la herramienta de generación de programas ULP para cargar el código binario del programa ULP:
import esp32
import ulptool
# 使用 ULP 程序生成工具生成 ULP 程序的二进制代码
ulp_source_code = """
.section .ulp_text
.global function_entry
function_entry:
# ULP 程序代码，请根据实际需求编写
"""
ulp_binary_code = ulptool.assemble(ulp_source_code)
# 加载 ULP 程序的二进制代码到 ULP 协处理器
esp32.ULP.load_binary(ulp_binary_code)
Este programa de muestra muestra cómo usar la herramienta de generación de programas ULP en el módulo ulptool escribiendo el código fuente del programa ULP y usando el método ensamblar() para generar código binario, y luego usando el método load_binary() para cargarlo en el Coprocesador ULP. Escriba el código del programa ULP según las necesidades reales.
Estos programas de muestra demuestran cómo cargar código binario en el coprocesador ULP del ESP32 usando el método esp32.ULP.load_binary(). Puede proporcionar código binario directamente al método, leer el código de un archivo o utilizar la herramienta de generación de programas ULP para generar el código. Asegúrese de que el código binario proporcionado cumpla con los requisitos del coprocesador ULP y esté cargado en el coprocesador ULP correctamente.
