MicroPython est une version allégée de l'interpréteur conçue pour exécuter le langage de programmation Python 3 dans les systèmes embarqués. Comparé au Python classique, l'interpréteur MicroPython est petit (seulement environ 100 Ko) et est compilé dans un fichier exécutable binaire à exécuter, ce qui entraîne une efficacité d'exécution plus élevée. Il utilise un mécanisme léger de récupération de place et supprime la plupart de la bibliothèque standard Python pour s'adapter aux microcontrôleurs aux ressources limitées.
Les principales fonctionnalités de MicroPython incluent :
1. La syntaxe et les fonctions sont compatibles avec le Python standard, ce qui le rend facile à apprendre et à utiliser. Prend en charge la plupart de la syntaxe de base de Python.
2. Accédez et contrôlez directement le matériel, contrôlez GPIO, I2C, SPI, etc. comme Arduino.
3. Système de modules puissant, fournissant un système de fichiers, un réseau, une interface graphique et d'autres fonctions.
4. Prise en charge de la compilation croisée pour générer du code natif efficace, 10 à 100 fois plus rapide que l'interpréteur.
5. La quantité de code est faible et l'utilisation de la mémoire est faible. Il convient pour fonctionner sur des MCU et des cartes de développement avec une petite mémoire.
6. Licence Open source, utilisation gratuite. L'environnement interactif Shell offre une commodité pour le développement et les tests.
7. Le pilote d'E/S intégré prend en charge un grand nombre de plates-formes de microcontrôleurs, telles que ESP8266, ESP32, STM32, micro:bit, carte de contrôle et PyBoard, etc. Il y a une communauté active.
Les scénarios d'application MicroPython incluent :
1. Créez rapidement des prototypes et des interactions utilisateur pour les produits intégrés.
2. Réalisez quelques petits projets de matériel programmable.
3. En tant qu'outil pédagogique, il aide les débutants à apprendre la programmation Python et IoT.
4. Créez un micrologiciel d'appareil intelligent pour obtenir un contrôle avancé et une connectivité cloud.
5. Diverses applications de microcontrôleurs telles que l'Internet des objets, l'intelligence embarquée, les robots, etc.
Points à noter lors de l'utilisation de MicroPython :
1. La mémoire et l'espace Flash sont limités.
2. L'efficacité de l'explication et de l'exécution n'est pas aussi bonne que celle du langage C.
3. Certaines fonctions de la bibliothèque sont différentes de la version standard.
4. Optimisez la syntaxe de la plateforme et corrigez les différences avec le Python standard.
5. Utilisez les ressources mémoire de manière rationnelle et évitez d'allouer fréquemment de gros blocs de mémoire.
6. Utilisez du code natif pour améliorer les performances des pièces critiques en termes de vitesse.
7. Utilisez l'abstraction de manière appropriée pour encapsuler les opérations matérielles sous-jacentes.
D'une manière générale, MicroPython introduit Python dans le domaine des microcontrôleurs, ce qui constitue une innovation importante qui non seulement abaisse le seuil de programmation, mais offre également de bonnes capacités de contrôle matériel. Il est très approprié pour le développement de divers types d'Internet des objets et de matériel intelligent.
OpenMV Cam est une petite carte microcontrôleur basse consommation qui vous permet de mettre en œuvre facilement des applications utilisant la vision industrielle dans le monde réel. Vous pouvez programmer OpenMV Cam à l'aide de scripts Python de haut niveau (fournis par MicroPython OS) au lieu de C/C++. Les paramètres techniques d'OpenMV Cam incluent les aspects suivants :
1. Processeur : OpenMV Cam H7 Plus utilise le processeur STM32H743II ARM Cortex M7, fonctionnant à 480 MHz, avec 32 Mo de SDRAM + 1 Mo de SRAM et 32 Mo de mémoire flash externe + 2 Mo de mémoire flash interne. OpenMV Cam M4 V2 utilise le processeur STM32F427VG ARM Cortex M4 fonctionnant à 180 MHz avec 256 Ko de RAM et 1 Mo de mémoire flash.
2. Capteur d'image : OpenMV Cam H7 Plus et OpenMV Cam M4 V2 utilisent le capteur d'image OV7725, qui peut capturer des images en niveaux de gris de 320 x 240 en 8 bits ou des images en niveaux de gris de 320 x 240 en 16 bits RVB565 à 75 FPS à des résolutions supérieures à 320 x 240. Capable de prendre des photos à 150 FPS à 320x240.
3. Interface E/S : OpenMV Cam H7 Plus et OpenMV Cam M4 V2 disposent toutes deux des interfaces E/S suivantes :
(1) Interface USB pleine vitesse (12 Mo), connectée à l'ordinateur. Lorsque l'OpenMV Cam est branchée, un port COM virtuel et une "clé USB" apparaîtront sur votre ordinateur.
(2) L'emplacement pour carte μSD est capable de lire/écrire 100 Mo, permettant à votre OpenMV Cam d'enregistrer des vidéos et d'extraire du matériel de vision industrielle de la carte μSD.
(3) Le bus SPI fonctionne à une vitesse allant jusqu'à 54 Mo, vous permettant de transmettre simplement des données de flux d'images à la carte d'extension LCD, à la carte d'extension WiFi ou à d'autres contrôleurs.
(4) Bus I2C (jusqu'à 1 Mb/s), bus CAN (jusqu'à 1 Mb/s) et bus série asynchrone (TX/RX, jusqu'à 7,5 Mb/s) pour la connexion avec d'autres contrôleurs ou capteurs.
(5) Un ADC 12 bits et un DAC 12 bits.
(6) Il y a des interruptions et du PWM sur toutes les broches d'E/S (il y a 9 ou 10 broches d'E/S sur la carte).
4. LED : L'OpenMV Cam H7 Plus et l'OpenMV Cam M4 V2 sont équipées d'une LED RVB (tricolore) et de deux LED IR lumineuses de 850 nm (infrarouge).
5. Objectif : OpenMV Cam H7 Plus et OpenMV Cam M4 V2 sont équipés d'une interface d'objectif M12 standard et d'un objectif par défaut de 2,8 mm. Si vous souhaitez utiliser un objectif plus professionnel avec votre OpenMV Cam, vous pouvez facilement l'acheter et l'installer vous-même.
OpenMV Cam de MicroPython prend en charge le suivi des couleurs et vous pouvez suivre des couleurs spécifiques en écrivant du code MicroPython. Ses principales caractéristiques, scénarios d'application et questions nécessitant une attention particulière seront expliquées en détail ci-dessous.
caractéristique principale:
Reconnaissance des couleurs : la fonction de suivi des couleurs d'OpenMV Cam peut identifier et suivre des objets de couleurs spécifiées. Vous pouvez spécifier une couleur qui vous intéresse en définissant la gamme de couleurs à suivre, et la caméra détectera cette couleur dans l'image en temps réel et fournira des informations pertinentes.
Performances en temps réel : OpenMV Cam offre des performances en temps réel élevées et peut capturer des images et effectuer un suivi des couleurs en temps réel. Cela le rend adapté aux scénarios d’application nécessitant une réponse rapide et un traitement en temps réel, tels que la navigation de robots, le suivi automatique, etc.
Développement simplifié : Le langage de programmation MicroPython est facile à apprendre et adapté aux débutants et aux domaines éducatifs. OpenMV Cam fournit une interface de programmation conviviale et un exemple de code, rendant le développement et le débogage du suivi des couleurs plus faciles et plus pratiques.
Scénarios d'application :
Navigation du robot : dans la navigation du robot, le suivi des couleurs peut être utilisé pour identifier des marqueurs ou des points de repère de couleurs spécifiques afin d'aider le robot à se positionner et à naviguer. Par exemple, dans un jeu de football robotisé, le suivi des cibles et le tir peuvent être effectués en identifiant des ballons et des buts de couleurs spécifiques.
Contrôle automatisé : le suivi des couleurs peut être utilisé dans les systèmes de contrôle automatisés pour détecter et suivre des objets de couleurs spécifiques. Par exemple, sur une chaîne de montage, le suivi des couleurs peut être utilisé pour localiser et suivre les pièces, permettant ainsi une manipulation et un tri automatisés des matériaux.
Projets de recherche pédagogique et scientifique : en tant qu'outil pour l'éducation et la recherche scientifique, la fonction de suivi des couleurs d'OpenMV Cam peut être utilisée pour mener diverses expériences et démonstrations pédagogiques. La mise en œuvre du suivi des couleurs en écrivant du code MicroPython peut aider les étudiants à comprendre des concepts tels que le traitement d'image, la vision par ordinateur et l'apprentissage automatique.
Choses à noter :
Conditions d’éclairage : le suivi des couleurs est sensible aux conditions d’éclairage. Différentes conditions d'éclairage peuvent affecter la reconnaissance des couleurs et les performances de suivi. Lorsque vous utilisez la fonction de suivi des couleurs, vous devez faire attention à l'uniformité et à l'intensité de la lumière pour obtenir des résultats plus précis.
Calibrage des couleurs : pour des résultats précis de suivi des couleurs, un calibrage des couleurs peut être nécessaire. L'étalonnage des couleurs peut aider le système à s'adapter aux différentes conditions d'éclairage et aux changements environnementaux, améliorant ainsi la précision et la robustesse du suivi des couleurs.
Forme et arrière-plan de l'objet : le suivi des couleurs est généralement basé sur les informations de couleur de l'objet, de sorte que la forme et l'arrière-plan de l'objet peuvent avoir un impact sur l'effet de suivi. Dans les applications, vous devez faire attention à la distinction entre la forme et l'arrière-plan de l'objet et à la couleur suivie pour éviter une erreur de jugement ou un échec de suivi.
En résumé, la fonction de suivi des couleurs d'OpenMV Cam de MicroPython peut identifier et suivre des objets de couleurs spécifiées et a de nombreuses applications dans des domaines tels que la navigation des robots, le contrôle automatisé, l'éducation et la recherche scientifique. Il possède des fonctionnalités clés telles que la reconnaissance des couleurs, des performances en temps réel et un développement simplifié. Lors de l'utilisation, vous devez faire attention à des facteurs tels que les conditions d'éclairage, l'étalonnage des couleurs, la forme et l'arrière-plan de l'objet. La fonction de suivi des couleurs peut aider à réaliser des tâches telles que le positionnement d'objets, la navigation et le contrôle automatique, et convient également aux expériences et aux démonstrations pédagogiques dans les domaines de l'éducation et de la recherche scientifique.
Cas 1 : utilisation de l'espace colorimétrique HSV pour le suivi des couleurs
import sensor, image, time
from pyb import HSV
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
while True:
img = sensor.snapshot() # 捕获一帧图像
hsv = img.to_hsv() # 将图像转换为HSV颜色空间
if hsv[2] > 100: # 如果饱和度大于100
img.draw_rectangle((50, 50, 100, 100), color=170, thickness=4) # 在图像上绘制一个矩形
time.sleep_ms(100) # 延时100毫秒
Interprétation : Ce programme importe d'abord les modules capteur, image, heure et pyb.HSV. Initialisez ensuite la caméra, définissez le format de pixel sur RVB565, la taille de l'image sur 320x240 et attendez que les paramètres prennent effet, avec un délai de 2 secondes. Ensuite, il entre dans une boucle infinie et capture en continu les images de la caméra. Chaque fois que vous capturez une image, convertissez-la en espace colorimétrique HSV et vérifiez si la saturation est supérieure à 100. Si la saturation est supérieure à 100, un rectangle est dessiné sur l'image avec une couleur de 170 (jaune). Le délai final est de 100 millisecondes.
Cas 2 : Utilisation de seuils de couleur pour le suivi des couleurs
import sensor, image, time
from pyb import THRESH_BINARY
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
threshold = (30, 100, 15, 127, 15, 127) # 设置颜色阈值
while True:
img = sensor.snapshot() # 捕获一帧图像
img.binary([threshold]) # 对图像进行二值化处理，根据颜色阈值进行分割
if img.pixel(50, 50) == 1: # 如果(50, 50)位置的颜色值为1
img.draw_rectangle((50, 50, 100, 100), color=170, thickness=4) # 在图像上绘制一个矩形
time.sleep_ms(100) # 延时100毫秒
Interprétation : Cette procédure est similaire au premier cas, sauf qu'un seuil de couleur est utilisé pour le suivi des couleurs. Tout d’abord, les modules capteur, image, heure et pyb.THRESH_BINARY ont été importés. Initialisez ensuite la caméra, définissez le format de pixel sur RVB565, la taille de l'image sur 320x240 et attendez que les paramètres prennent effet, avec un délai de 2 secondes. Ensuite, un tuple de seuil de couleur est défini. Dans une boucle infinie, les images de la caméra sont capturées en continu. Une fois chaque image capturée, elle est binarisée et segmentée en fonction de seuils de couleur. Si la valeur de couleur en (50, 50) est 1, dessinez un rectangle sur l'image avec une couleur de 170 (jaune). Le délai final est de 100 millisecondes.
Cas 3 : Suivi des couleurs à l’aide de la distance des couleurs
import sensor, image, time
from pyb import COLOR_RED, COLOR_GREEN, COLOR_BLUE, THRESH_BINARY
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
colors = {
'red': (COLOR_RED, THRESH_BINARY),
'green': (COLOR_GREEN, THRESH_BINARY),
'blue': (COLOR_BLUE, THRESH_BINARY)
}
while True:
img = sensor.snapshot() # 捕获一帧图像
for color, threshold in colors.items():
if img.get_pixel(50, 50)[color] > threshold: # 如果(50, 50)位置的当前颜色值大于阈值
img.draw_rectangle((50, 50, 100, 100), color=170, thickness=4) # 在图像上绘制一个矩形
time.sleep_ms(100) # 延时100毫秒
Interprétation : Cette procédure est similaire au deuxième cas, sauf qu'elle utilise la distance des couleurs pour le suivi des couleurs. Tout d'abord, les modules capteur, image, heure et pyb.COLOR_RED, pyb.COLOR_GREEN, pyb.COLOR_BLUE et pyb.THRESH_BINARY ont été importés. Initialisez ensuite la caméra, définissez le format de pixel sur RVB565, la taille de l'image sur 320x240 et attendez que les paramètres prennent effet, avec un délai de 2 secondes. Ensuite, un dictionnaire de couleurs est défini, qui contient trois couleurs : rouge, vert et bleu et leurs seuils correspondants. Dans une boucle infinie, les images de la caméra sont capturées en continu. Une fois chaque image capturée, parcourez le dictionnaire de couleurs et vérifiez si la valeur de couleur actuelle à la position (50, 50) est supérieure au seuil. S'il est supérieur au seuil, un rectangle est dessiné sur l'image de couleur 170 (jaune). Le délai final est de 100 millisecondes.
Cas 4 : Suivi d’une seule couleur :
import sensor
import image
import time
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
red_threshold = (30, 100, 15, 127, 15, 127) # 设置红色阈值
while True:
img = sensor.snapshot()
blobs = img.find_blobs([red_threshold])
if blobs:
for blob in blobs:
img.draw_rectangle(blob.rect())
img.draw_cross(blob.cx(), blob.cy())
time.sleep(10)
Interprétation des points clés :
Ce programme utilise le module capteur et le module image d'OpenMV Cam pour le suivi des couleurs.
Utilisez sensor.reset() pour réinitialiser les paramètres du capteur.
Utilisez sensor.set_pixformat(sensor.RGB565) pour définir le format de pixel sur RGB565.
Utilisez sensor.set_framesize(sensor.QVGA) pour définir la taille de l'image sur QVGA.
Utilisez sensor.skip_frames(time=2000) pour sauter 2 secondes d'images afin de permettre au capteur de se stabiliser.
Un seuil rouge red_threshold est défini pour identifier les objets rouges. Le format du seuil est (minR, maxR, minG, maxG, minB, maxB).
Dans une boucle infinie, demandez au programme de continuer à effectuer les opérations suivantes :
Utilisez sensor.snapshot() pour obtenir l'image actuelle.
Utilisez img.find_blobs([red_threshold]) pour rechercher les zones d'objets qui répondent au seuil rouge.
Si des zones d'objets (blobs) sont trouvées, procédez comme suit pour chaque zone :
utilisez img.draw_rectangle(blob.rect()) pour dessiner une boîte rectangulaire sur l'image afin de marquer la zone d'objet.
Utilisez img.draw_cross(blob.cx(), blob.cy()) pour dessiner une croix sur l'image pour marquer la position centrale de l'objet.
Utilisez time.sleep(10) pour retarder 10 millisecondes afin de contrôler le taux d'exécution de la boucle.
Cas 5 : Suivi de plusieurs couleurs :
import sensor
import image
import time
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
red_threshold = (30, 100, 15, 127, 15, 127) # 红色阈值
blue_threshold = (0, 30, 0, 64, 128, 255) # 蓝色阈值
while True:
img = sensor.snapshot()
red_blobs = img.find_blobs([red_threshold])
blue_blobs = img.find_blobs([blue_threshold])
if red_blobs:
for blob in red_blobs:
img.draw_rectangle(blob.rect())
img.draw_cross(blob.cx(), blob.cy())
if blue_blobs:
for blob in blue_blobs:
img.draw_rectangle(blob.rect())
img.draw_cross(blob.cx(), blob.cy())
time.sleep(10)
Interprétation des points clés :
Ce programme utilise le module capteur et le module image d'OpenMV Cam pour suivre plusieurs couleurs.
Comme dans le premier exemple, les paramètres du capteur et de l'image sont définis, ainsi que les seuils rouge et bleu.
Dans une boucle infinie, demandez au programme de continuer à effectuer les opérations suivantes :
Utilisez sensor.snapshot() pour obtenir l'image actuelle.
Utilisez img.find_blobs([red_threshold]) pour rechercher les zones d'objets qui répondent au seuil rouge.
Utilisez img.find_blobs([blue_threshold]) pour rechercher les zones d'objets qui répondent au seuil bleu.
Si des zones d'objet rouges (red_blobs) sont trouvées, procédez comme suit pour chaque zone :
utilisez img.draw_rectangle(blob.rect()) pour dessiner une boîte rectangulaire sur l'image afin de marquer la zone de l'objet.
Utilisez img.draw_cross(blob.cx(), blob.cy()) pour dessiner une croix sur l'image pour marquer la position centrale de l'objet.
Si des régions d'objets bleus (blue_blobs) sont trouvées, des opérations similaires sont effectuées pour chaque région.
Utilisez time.sleep(10) pour retarder 10 millisecondes afin de contrôler le taux d'exécution de la boucle.
Cas 6 : Suivi des couleurs et sortie de position :
import sensor
import image
import time
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
red_threshold = (30, 100, 15, 127, 15, 127) # 红色阈值
while True:
img = sensor.snapshot()
blobs = img.find_blobs([red_threshold])
if blobs:
for blob in blobs:
img.draw_rectangle(blob.rect())
img.draw_cross(blob.cx(), blob.cy())
print("Detected red object at X:%d, Y:%d" % (blob.cx(), blob.cy()))
time.sleep(10)
Interprétation des points clés :
ce programme utilise le module de capteur et le module d'image d'OpenMV Cam pour le suivi des couleurs et génère les informations de position de l'objet.
Comme dans les deux exemples précédents, les paramètres du capteur et de l'image sont définis, ainsi que le seuil de rouge.
Dans une boucle infinie, demandez au programme de continuer à effectuer les opérations suivantes :
Utilisez sensor.snapshot() pour obtenir l'image actuelle.
Utilisez img.find_blobs([red_threshold]) pour rechercher les zones d'objets qui répondent au seuil rouge.
Si des zones d'objets (blobs) sont trouvées, procédez comme suit pour chaque zone :
utilisez img.draw_rectangle(blob.rect()) pour dessiner une boîte rectangulaire sur l'image afin de marquer la zone d'objet.
Utilisez img.draw_cross(blob.cx(), blob.cy()) pour dessiner une croix sur l'image pour marquer la position centrale de l'objet.
Utilisez la fonction print() pour afficher les informations de position de l'objet, c'est-à-dire les coordonnées centrales de l'objet.
Utilisez time.sleep(10) pour retarder 10 millisecondes afin de contrôler le taux d'exécution de la boucle.
Cas 7 : programme simple de suivi des couleurs
import sensor, image, time
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
threshold = (120, 255, 120, 255) # 设置颜色阈值，这里是绿色
while(True):
img = sensor.snapshot() # 拍摄照片
blobs = img.find_blobs([threshold]) # 查找颜色块
if len(blobs) > 0: # 如果找到了颜色块
print(blobs[0].center()) # 打印颜色块中心坐标
Interprétation des points clés :
initialisez d'abord l'appareil photo et définissez le format de pixel et la taille de l'image.
Définissez le seuil de couleur. L'espace colorimétrique RVB est utilisé ici et le seuil est vert.
Dans une boucle infinie, prenez une photo et retrouvez des blocs de couleurs.
Si un bloc de couleur est trouvé, ses coordonnées centrales sont imprimées.
Cas 8 : Afficher les résultats du suivi des couleurs sur l'écran 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) # 等待摄像头稳定
threshold = (120, 255, 120, 255) # 设置颜色阈值，这里是绿色
while(True):
img = sensor.snapshot() # 拍摄照片
blobs = img.find_blobs([threshold]) # 查找颜色块
if len(blobs) > 0: # 如果找到了颜色块
lcd.clear() # 清空LCD屏幕
lcd.draw_rectangle(blobs[0].rect(), lcd.COLOR_RED) # 在LCD屏幕上绘制颜色块边界框
Interprétation des points clés :
initialisez d'abord l'écran LCD et l'appareil photo, définissez le format de pixel et la taille du cadre.
Définissez le seuil de couleur. L'espace colorimétrique RVB est utilisé ici et le seuil est vert.
Dans une boucle infinie, prenez une photo et retrouvez des blocs de couleurs.
Si un bloc de couleur est trouvé, l'écran LCD est effacé et le cadre de délimitation du bloc de couleur est dessiné dessus. Utilisez la fonction draw_rectangle() pour dessiner un rectangle.
Cas 9 : Utilisation du suivi des couleurs pour contrôler le mouvement du robot
import sensor, image, time, pyb, machine
motor1 = machine.PWM(pyb.Pin('X1'), freq=100) # 初始化电机1引脚为PWM输出，频率为100Hz
motor2 = machine.PWM(pyb.Pin('X2'), freq=100) # 初始化电机2引脚为PWM输出，频率为100Hz
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
threshold = (120, 255, 120, 255) # 设置颜色阈值，这里是绿色
speed = 1000 # 设置电机速度，这里是1000（占空比）
while(True):
img = sensor.snapshot() # 拍摄照片
blobs = img.find_blobs([threshold]) # 查找颜色块
if len(blobs) > 0: # 如果找到了颜色块
x, y = blobs[0].center() # 获取颜色块中心坐标
if x < img.width() / 2: # 如果颜色块在图像左半部分
motor1.duty(speed) # 左电机前进
motor2.duty(0) # 右电机停止
else: # 如果颜色块在图像右半部分
motor1.duty(0) # 左电机停止
motor2.duty(speed) # 右电机前进
else: # 如果没有找到颜色块
motor1.duty(0) # 左电机停止
motor2.duty(0) # 右电机停止
time.sleep(100) # 延时100ms，以减少CPU的使用率
Interprétation des points clés :
Initialisez d'abord la broche du moteur sur la sortie PWM et réglez la fréquence sur 100 Hz. Initialisez l'appareil photo et définissez le format de pixel et la taille de l'image.
Définissez le seuil de couleur. L'espace colorimétrique RVB est utilisé ici et le seuil est vert. Réglez la vitesse du moteur, ici elle est de 1000 (rapport cyclique).
Dans une boucle infinie, prenez une photo et retrouvez des blocs de couleurs. Si un bloc de couleur est trouvé, le moteur est commandé pour avancer ou s'arrêter en fonction de la position du bloc de couleur. Si aucun bloc de couleur n'est trouvé, les deux moteurs s'arrêtent. Utilisez la fonction duty() pour définir le cycle de service du moteur.
Utilisez la fonction time.sleep() pour retarder 100 ms afin de réduire l'utilisation du processeur.
Ces exemples d'applications pratiques montrent comment utiliser MicroPython et OpenMV Cam pour le suivi des couleurs. Le premier exemple montre comment suivre une seule couleur (rouge) en définissant un seuil de couleur et en utilisant img.find_blobs() pour la détection d'objets. Le deuxième exemple montre comment suivre plusieurs couleurs (rouge et bleu) simultanément en définissant différents seuils de couleur et en utilisant img.find_blobs() séparément pour la détection d'objets. Le troisième exemple montre comment afficher les informations de position d'un objet en dessinant des rectangles et des croix sur l'image et en utilisant la fonction print() pour afficher les coordonnées centrales de l'objet. En fonction de vos besoins spécifiques, vous pouvez modifier et étendre ces exemples pour implémenter des fonctionnalités et des applications de suivi des couleurs plus complexes.
Veuillez noter que les cas ci-dessus servent uniquement à développer des idées et peuvent contenir des erreurs ou des inapplicabilités. Différentes plates-formes matérielles, scénarios d'utilisation et versions de MicroPython peuvent conduire à différentes méthodes d'utilisation. En programmation réelle, vous devez l'ajuster en fonction de votre configuration matérielle et de vos besoins spécifiques, et effectuer plusieurs tests réels. Il est important de s’assurer que le matériel est correctement connecté et de comprendre les spécifications et caractéristiques des capteurs et appareils utilisés.
