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.
OpenMV Cam es una pequeña placa microcontroladora de bajo consumo que le permite implementar fácilmente aplicaciones utilizando visión artificial en el mundo real. Puede programar OpenMV Cam utilizando scripts Python de alto nivel (proporcionados por MicroPython OS) en lugar de C/C++. Los parámetros técnicos de OpenMV Cam incluyen los siguientes aspectos:
1. Procesador: OpenMV Cam H7 Plus utiliza el procesador STM32H743II ARM Cortex M7, que funciona a 480 MHz, con 32 MB de SDRAM + 1 MB de SRAM y 32 MB de memoria flash externa + 2 MB de memoria flash interna. OpenMV Cam M4 V2 utiliza el procesador STM32F427VG ARM Cortex M4 que funciona a 180 MHz con 256 KB de RAM y 1 MB de memoria flash.
2. Sensor de imagen: Tanto OpenMV Cam H7 Plus como OpenMV Cam M4 V2 utilizan el sensor de imagen OV7725, que puede capturar imágenes en escala de grises de 320x240 de 8 bits o imágenes RGB565 de 320x240 de 16 bits a 75 FPS con resoluciones superiores a 320x240. 150 FPS a 320x240.
3. Interfaz de E/S: OpenMV Cam H7 Plus y OpenMV Cam M4 V2 tienen las siguientes interfaces de E/S:
(1) Interfaz USB de velocidad completa (12 Mbs), conectada a la computadora. Cuando la OpenMV Cam esté conectada, aparecerá un puerto COM virtual y una "unidad flash USB" en su computadora.
(2) La ranura para tarjeta μSD tiene capacidad de lectura/escritura de 100 MB, lo que permite que su OpenMV Cam grabe video y extraiga material de visión artificial de la tarjeta μSD.
(3) El bus SPI funciona a una velocidad de hasta 54 Mbs, lo que le permite simplemente transmitir datos de flujo de imágenes a la placa de expansión LCD, placa de expansión WiFi u otros controladores.
(4) Bus I2C (hasta 1 Mb/s), bus CAN (hasta 1 Mb/s) y bus serie asíncrono (TX/RX, hasta 7,5 Mb/s) para conexión con otros controladores o sensores.
(5) Un ADC de 12 bits y un DAC de 12 bits.
(6) Hay interrupciones y PWM en todos los pines de E/S (hay 9 o 10 pines de E/S en la placa).
4. LED: Tanto OpenMV Cam H7 Plus como OpenMV Cam M4 V2 están equipados con un LED RGB (tricolor) y dos LED IR brillantes de 850 nm (infrarrojos).
5. Lente: Tanto OpenMV Cam H7 Plus como OpenMV Cam M4 V2 están equipados con una interfaz de lente M12 estándar y una lente predeterminada de 2,8 mm. Si desea utilizar una lente más profesional con su OpenMV Cam, puede comprarla e instalarla fácilmente usted mismo.
OpenMV Cam de MicroPython admite la función de disparo en tiempo real, que puede capturar imágenes y videos en tiempo real escribiendo código MicroPython.
caracteristica principal:
Rendimiento rápido en tiempo real: OpenMV Cam tiene un alto rendimiento en tiempo real y puede capturar imágenes y vídeos en tiempo real. Está equipado con un procesador de imágenes de alto rendimiento y un sensor que puede capturar y procesar imágenes a una velocidad de fotogramas estable, lo que permite capacidades de captura en tiempo real.
Múltiples resoluciones y formatos: OpenMV Cam admite disparos en tiempo real en múltiples resoluciones y formatos de imagen. Puede elegir la resolución y el formato adecuados según las necesidades de su aplicación para cumplir con los requisitos de disparo en diferentes escenarios.
Procesamiento de imágenes flexible: OpenMV Cam tiene funciones y algoritmos de procesamiento de imágenes enriquecidos integrados, que incluyen filtrado, detección de bordes, reconocimiento de color y otras funciones. Esto permite que la captura en tiempo real vaya más allá de la simple captura de imágenes para permitir el procesamiento y análisis de imágenes en tiempo real.
Desarrollo simplificado: el lenguaje de programación MicroPython es fácil de aprender y adecuado para principiantes y campos educativos. OpenMV Cam proporciona una interfaz de programación amigable y un código de muestra, lo que hace que el desarrollo y la depuración de funciones de disparo en tiempo real sean más fáciles y convenientes.
Escenarios de aplicación:
Monitoreo y seguimiento visual: las capacidades de disparo en tiempo real de OpenMV Cam se pueden aplicar a los sistemas de seguimiento y monitoreo visual. Por ejemplo, se puede utilizar para la navegación visual de drones, capturando imágenes del entorno circundante en tiempo real y realizando análisis y procesamiento en tiempo real para lograr un posicionamiento preciso y evitar obstáculos.
Docencia e investigación científica: la función de disparo en tiempo real se puede utilizar para proyectos de enseñanza e investigación científica. Los estudiantes e investigadores pueden utilizar OpenMV Cam para realizar experimentos e investigaciones sobre la adquisición y el procesamiento de imágenes en tiempo real, y explorar conocimientos en visión por computadora, procesamiento de imágenes y otros campos relacionados.
Videovigilancia: OpenMV Cam se puede utilizar en sistemas de videovigilancia en tiempo real, como sistemas de seguridad interiores o monitoreo de líneas de producción industrial. Mediante disparos y análisis en tiempo real, se pueden descubrir situaciones anormales a tiempo y se pueden tomar las medidas correspondientes.
Cosas a tener en cuenta:
Almacenamiento: la función Live Capture puede requerir una gran cantidad de espacio de almacenamiento para almacenar imágenes o videos capturados. Cuando utilice OpenMV Cam para tomas en vivo, debe asegurarse de que haya suficiente espacio de almacenamiento para almacenar datos o usar un dispositivo de almacenamiento externo para expandirlo.
Fuente de alimentación: la función de disparo en tiempo real tiene mayores requisitos de suministro de energía, especialmente cuando se dispara durante mucho tiempo o de forma continua. Cuando utilice OpenMV Cam para grabar en tiempo real, debe garantizar una fuente de alimentación estable para evitar problemas causados por una batería insuficiente o una interrupción del suministro eléctrico.
Rendimiento del procesamiento: capturar y procesar imágenes en tiempo real puede requerir ciertos recursos informáticos. Al realizar tomas en tiempo real, es necesario evaluar el rendimiento de procesamiento de OpenMV Cam para garantizar que pueda cumplir con los requisitos de procesamiento en tiempo real requeridos.
En resumen, la función de disparo en tiempo real de OpenMV Cam de MicroPython tiene las características de un rendimiento rápido en tiempo real, procesamiento de imágenes flexible y desarrollo simplificado. Es adecuado para escenarios como monitoreo y seguimiento visual, enseñanza e investigación científica y videovigilancia. Al usarlo, debe prestar atención a factores como el espacio de almacenamiento, la fuente de alimentación y el rendimiento del procesamiento, y configurar y optimizar parámetros de acuerdo con necesidades y escenarios específicos.
Caso 1: programa sencillo de disparo en tiempo real
import sensor, image, time
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
while(True):
img = sensor.snapshot() # 拍摄照片
print(img) # 打印照片
Interpretación de puntos clave:
inicialice la cámara, establezca el formato de píxeles y el tamaño del fotograma. En un bucle infinito, utilice la función instantánea() para tomar fotografías en tiempo real e imprimirlas.
Caso 2: Dispare en tiempo real y muestre la imagen en la pantalla LCD
import sensor, image, time, lcd
lcd.init() # 初始化LCD屏幕
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
while(True):
img = sensor.snapshot() # 拍摄照片
lcd.display(img) # 在LCD屏幕上显示图像
Interpretación de los puntos clave:
primero inicialice la pantalla LCD y la cámara, configure el formato de píxeles y el tamaño del cuadro. En un bucle infinito, se toma una foto en tiempo real usando la función snapshot() y la imagen se muestra en la pantalla LCD usando la función display().
Caso 3: Dispara y detecta rostros en tiempo real
import sensor, image, time, facedetect
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
face_cascade = facedetect.Cascade('haarcascade_frontalface_default.xml') # 加载人脸检测器
while(True):
img = sensor.snapshot() # 拍摄照片
faces = face_cascade.find(img) # 检测人脸
if len(faces) > 0: # 如果检测到了人脸
for face in faces: # 在每个检测到的人脸周围绘制矩形框
img.draw_rectangle(face.rect(), color = (255, 0, 0), thickness = 2)
print(img) # 打印标记了人脸的照片
Interpretación de los puntos clave:
primero inicialice la cámara y configure el formato de píxeles y el tamaño del fotograma. Cargue el detector de rostros, aquí se utiliza el clasificador en cascada Haar proporcionado por OpenCV. En un bucle infinito, use la función snapshot() para tomar fotografías en tiempo real y use la función find() para detectar rostros. Si se detectan caras, dibuje un cuadro rectangular alrededor de cada cara detectada y use la función draw_rectangle() para dibujar el cuadro rectangular. Finalmente imprime la foto con la cara etiquetada.
Caso 4: Visualización en tiempo real del metraje de la cámara
import sensor, image, time
sensor.reset() # 初始化传感器
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为QVGA
sensor.skip_frames(time = 2000) # 等待2秒，让红外接收器稳定
while(True):
img = sensor.snapshot() # 获取一帧图像
lcd.display(img) # 在LCD上显示图像
time.sleep_ms(30) # 每隔30毫秒更新一次LCD
Interpretación de puntos clave: Primero importe los módulos de sensor, imagen y tiempo. Luego inicialice el sensor y configure el formato de píxel y el tamaño del cuadro. Luego espere 2 segundos hasta que se estabilice el receptor de infrarrojos. En el bucle while, se obtiene y muestra continuamente un cuadro de imagen en la pantalla LCD, y la pantalla LCD se actualiza cada 30 milisegundos.
Caso 5: Tome fotografías en tiempo real y guárdelas en la tarjeta SD
import sensor, image, time, os
sensor.reset() # 初始化传感器
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为QVGA
sensor.skip_frames(time = 2000) # 等待2秒，让红外接收器稳定
while(True):
img = sensor.snapshot() # 获取一帧图像
img.save("photo_{}.bmp".format(int(time.time()))) # 将图像保存为BMP格式
time.sleep_ms(30) # 每隔30毫秒更新一次LCD
os.system("ls /sd/") # 查看SD卡中的文件列表
Interpretación de puntos clave: Primero importe los módulos de sensor, imagen, tiempo y sistema operativo. Luego inicialice el sensor y configure el formato de píxel y el tamaño del cuadro. Luego espere 2 segundos hasta que se estabilice el receptor de infrarrojos. En el bucle while, obtenga continuamente un cuadro de imagen y guárdelo como una fotografía en formato BMP, mientras actualiza la pantalla LCD cada 30 milisegundos y visualiza la lista de archivos en la tarjeta SD.
Caso 6: Visualización en tiempo real de imágenes de cámara y grabación de vídeo
import sensor, image, time, cv2
sensor.reset() # 初始化传感器
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为QVGA
sensor.skip_frames(time = 2000) # 等待2秒，让红外接收器稳定
fourcc = cv2.VideoWriter_fourcc(*'XVID') # 定义视频编码格式
out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640, 480)) # 创建视频写入对象
while(True):
img = sensor.snapshot() # 获取一帧图像
img.save("photo_{}.bmp".format(int(time.time()))) # 将图像保存为BMP格式
time.sleep_ms(30) # 每隔30毫秒更新一次LCD
ret, frame = cap.read() # 从摄像头读取一帧图像
out.write(frame) # 将图像写入视频文件
cv2.imshow('frame', frame) # 在窗口中显示图像
if cv2.waitKey(1) & 0xFF == ord('q'): # 如果按下q键则退出程序
break
out.release() # 释放视频写入对象
cv2.destroyAllWindows() # 关闭所有窗口
Interpretación de puntos clave: Primero importe los módulos de sensor, imagen, tiempo y cv2. Luego inicialice el sensor y configure el formato de píxel y el tamaño del cuadro. Luego espere 2 segundos hasta que se estabilice el receptor de infrarrojos. En el bucle while, obtenga continuamente un cuadro de imagen y guárdelo como una foto en formato BMP, mientras actualiza la pantalla LCD cada 30 milisegundos, lee un cuadro de imagen de la cámara y lo escribe en un archivo de video. Finalmente, la imagen se muestra en la ventana y el programa sale si se presiona la tecla q.
Caso 7: Visualización en tiempo real de imágenes de la cámara:
import sensor
import image
import lcd
lcd.init()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
while True:
img = sensor.snapshot()
lcd.display(img)
Interpretación de puntos clave:
este programa utiliza el módulo de sensor y el módulo LCD de OpenMV Cam para mostrar la imagen de la cámara en tiempo real.
Utilice lcd.init() para inicializar la pantalla LCD.
Utilice sensor.reset() para restablecer el sensor de la cámara.
Utilice sensor.set_pixformat(sensor.RGB565) para configurar el formato de píxeles de la imagen en RGB565.
Utilice sensor.set_framesize(sensor.QVGA) para establecer el tamaño del marco de la imagen en QVGA (320x240).
Utilice sensor.run(1) para iniciar la transmisión de imágenes de la cámara.
En un bucle infinito, haz que el programa continúe haciendo lo siguiente:
capturar la imagen de la cámara usando sensor.snapshot() y almacenarla en la variable img.
Utilice lcd.display(img) para mostrar una imagen en la pantalla LCD.
Caso 8: Detectar y mostrar rostros en imágenes en tiempo real:
import sensor
import image
import lcd
import time
import uos
from fpioa_manager import *
lcd.init()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
# 加载人脸检测模型
model_path = "/sd/models/face_detection/face_detection.kmodel"
fm.register(board_info.PIN9, fm.fpioa.GPIOHS0)
time.sleep(1)
lcd.clear()
try:
face_detect = KPUClassify(model_path)
except Exception as e:
print(e)
while True:
img = sensor.snapshot()
# 进行人脸检测
faces = face_detect.detect(img)
for face in faces:
# 在图像上绘制人脸框
img.draw_rectangle(face.rect(), color=(255, 0, 0))
lcd.display(img)
Interpretación de puntos clave:
este programa utiliza el módulo de sensor, el módulo LCD y el módulo KPU de OpenMV Cam para detectar y mostrar el rostro en la imagen en tiempo real.
Utilice lcd.init() para inicializar la pantalla LCD.
Utilice sensor.reset() para restablecer el sensor de la cámara.
Utilice sensor.set_pixformat(sensor.RGB565) para configurar el formato de píxeles de la imagen en RGB565.
Utilice sensor.set_framesize(sensor.QVGA) para establecer el tamaño del marco de la imagen en QVGA (320x240).
Utilice sensor.run(1) para iniciar la transmisión de imágenes de la cámara.
En el bloque try-except, cargue el modelo de detección de rostros (la ruta en la tarjeta SD es /sd/models/face_detection/face_detection.kmodel).
En un bucle infinito, haz que el programa continúe haciendo lo siguiente:
capturar la imagen de la cámara usando sensor.snapshot() y almacenarla en la variable img.
Utilice el modelo de detección de rostros face_detect para detectar rostros en la imagen y almacene los rostros detectados en las caras variables.
Para cada rostro detectado, use img.draw_rectangle(face.rect(), color=(255, 0, 0)) para dibujar el cuadro de la cara en la imagen, de color rojo.
Utilice lcd.display(img) para mostrar una imagen con un marco de cara en la pantalla LCD.
Caso 9: Cálculo en tiempo real de la velocidad de fotogramas de la imagen:
import sensor
import image
import time
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
frame_count = 0
start_time = time.time()
while True:
img = sensor.snapshot()
frame_count += 1
if frame_count % 100 == 0:
current_time = time.time()
elapsed_time = current_time - start_time
fps = frame_count / elapsed_time
print("FPS:", fps)
Interpretación de puntos clave:
este programa utiliza el módulo de sensor de OpenMV Cam para calcular la velocidad de fotogramas de la imagen en tiempo real.
Utilice sensor.reset() para restablecer el sensor de la cámara.
Utilice sensor.set_pixformat(sensor.RGB565) para configurar el formato de píxeles de la imagen en RGB565.
Utilice sensor.set_framesize(sensor.QVGA) para establecer el tamaño del marco de la imagen en QVGA (320x240).
Utilice sensor.run(1) para iniciar la transmisión de imágenes de la cámara.
Inicialice el recuento de fotogramas frame_count en 0 y registre la hora de inicio del programa start_time.
En un bucle infinito, haz que el programa continúe haciendo lo siguiente:
capturar la imagen de la cámara usando sensor.snapshot() y almacenarla en la variable img.
Cada vez que se capturen 100 fotogramas, realice las siguientes operaciones:
Obtenga la hora actual hora_actual.
Calcule el tiempo transcurrido tiempo_transcurrido, que es la hora actual menos la hora de inicio del programa.
Calcule la velocidad de fotogramas fps como el número de fotogramas dividido por el tiempo transcurrido.
Utilice print() para generar la velocidad de fotogramas.
Estos códigos de muestra proporcionan el marco básico para la captura en vivo usando MicroPython y OpenMV Cam. Puedes modificar y ampliar estos códigos según tus necesidades, como añadir algoritmos de procesamiento de imágenes, interactuar con otros sensores o módulos, etc.
Tenga en cuenta que los casos anteriores son sólo para ampliar ideas y pueden contener errores o inaplicabilidad. Diferentes plataformas de hardware, escenarios de uso y versiones de MicroPython pueden dar lugar a diferentes métodos de uso. En la programación real, debe ajustarla de acuerdo con la configuración de su hardware y sus necesidades específicas, y realizar múltiples pruebas reales. Es importante asegurarse de que el hardware esté conectado correctamente y comprender las especificaciones y características de los sensores y dispositivos utilizados.
