Implémentation d'un algorithme PID utilisant la vision par ordinateur

Je construis un solveur de labyrinthe automatique et utilise une webcam pour contrôler mon labyrinthe.

Sur la base des suggestions d'autres forums, j'essaie de contrôler le mouvement de la balle du labyrinthe au moins dans une direction pour le moment. Donc, j'essaie de contrôler le mouvement de ma balle entre deux coordonnées 466,288 et 466,152. L'entrée à la carte contrôleur de moteur pas à pas est le temps, pas d'étapes à tourner pour chaque axe, c'est-à-dire x et y.

La carte contrôleur de moteur pas à pas que j'utilise est la carte contrôleur de moteur pas à pas d'oeuf bot: http://www.sparkfun.com/products/10025

Donc, pour me déplacer entre deux points, dois-je créer un certain nombre de points de passage entre les deux points, à savoir 288 et 152 (disons 260 240 230 ... 150) et corriger le mouvement de ma balle?

Mon algorithme de traitement d'image n'est pas assez rapide pour suivre la balle et la faire tourner et tomber dans un trou.

Certains m'ont suggéré d'utiliser un modèle standard comme indiqué dans la vidéo suivante et de corriger mes mouvements de balle pour les écarts sur le chemin:

http://www.youtube.com/watch?v=Prq78ctJ2Rk&feature=player_embedded

Je suis également tombé sur un outil de traitement d'image où ils ont résolu le même problème en utilisant des points de cheminement pour le mouvement de la balle. En voyant trop de solutions au même problème, je suis totalement confus quant à la résolution du problème. Je suis conscient que je dois implémenter un contrôleur PID. Mais comment dois-je procéder pour résoudre les problèmes par étapes? Je suis coincé et frustré de trouver une longueur d'avance pour résoudre le problème.

Ma configuration ressemble à ceci:

... et voici une capture d'écran de mon logiciel:

Révision 2: Je suis également confronté à un nouveau problème maintenant: plus tôt, je contrôlais les moteurs pas à pas via l'applet Java du port série Arduino. Je peux piloter les steppers en utilisant l'applet.

Je dois réinitialiser la carte à chaque fois que j'essaie de communiquer via le port série. De plus, le moteur pas à pas s'alimente par petits intervalles lorsqu'aucune commande ne lui est envoyée. Lorsque le moteur pas à pas entre dans ce mode, je ne peux pas contrôler ma carte sans réinitialiser la carte. Toute aide serait appréciée.

Révision 3:

J'ai fait des progrès où j'ai obtenu l'algorithme PID implémenté. Veuillez trouver la vidéo ci-dessous: http://www.youtube.com/watch?v=MEfp7RqPmqY

Maintenant, j'ai un problème avec la vitesse à laquelle l'algorithme PID est implémenté. En fait, mon traitement d'image termine un cycle en 200 ms, identifie une balle et envoie les commandes à la carte contrôleur du moteur pas à pas. Même si mon port série reçoit des commandes pour changer de direction, mon stepper continue de tourner dans le même sens. Vous pouvez trouver le comportement étrange dans la vidéo ci-dessus.

Ma pensée est que je devrais limiter les valeurs PID avec un plafond où si la valeur PID calculée est supérieure à 100, je devrais simplement envoyer 100. Je suis impatient d'entendre vos réflexions à ce sujet.

La façon dont j'ai implémenté le contrôleur PID est que j'ai identifié le point de départ du modèle en utilisant l'algorithme de correspondance de modèle et identifié la balle en utilisant un autre algorithme de correspondance de modèle. Maintenant, j'ai fait déplacer la balle vers le centre de gravité du modèle de point de départ. Comment puis-je lui faire suivre la ligne droite avec l'algorithme PID?

Révision 4:

J'ai isolé la trajectoire mais je ne parviens pas à trouver la fonction correcte pour imprimer les coordonnées de pixels correctes à partir du point de départ. Des pensées?

Tout d'abord, étant donné que les steppers sont excellents pour le positionnement (il n'y a pas besoin de retour de position), vous devez certainement limiter leur mouvement comme vous l'avez dit vous-même. Je ne sais pas comment l'arbre du moteur est conçu en ce moment, mais s'il était fixé au moteur, le laisser continuer à tourner risquerait d'endommager l'équipement.

Ensuite, un retard de transport de 200 ms dans votre capteur sera probablement trop lent, sinon vous devrez beaucoup ralentir les choses afin de ralentir la balle elle-même. Semblable à ce que Rocket Surgeon a dit, vous devez simplifier l'algorithme de traitement d'image pour calculer le chemin une seule fois , puis calculer rapidement uniquement la position de la balle dans chaque image. Si vous souhaitez ignorer cette étape rapidement, recherchez une boule rouge au lieu de celle-ci, puis vérifiez uniquement la composante rouge de votre image RVB, jusqu'à ce que vous ayez trouvé un meilleur algorithme.

Pour le contrôle PID, commencez par le fait que vous avez réellement besoin de deux contrôleurs PID distincts, un pour le moteur est-ouest, l'autre pour le nord-sud. Si vous avez deux moteurs exacts, leurs paramètres doivent être égaux.

Pour qu'un contrôleur PID agisse, il doit connaître l' erreur : différence entre la position souhaitée et la position réelle de la balle. Composantes X et Y de ce décalage seront les entrées pour les deux régulateurs PID (un pour chaque moteur). Pour obtenir l'erreur, vous devez d'abord avoir la position souhaitée sur votre chemin: une trajectoire .

Pour obtenir la trajectoire, vous devez traiter l'image et obtenir le chemin , ainsi que son point de départ et de fin. Je ne sais pas si votre algorithme est capable de distinguer le chemin du reste de la carte en ce moment, mais sinon, notez que c'est un algorithme à gérer avant de continuer. Encore une fois, vous pouvez ignorer cette partie en entrant manuellement les points de jonction, si vous êtes impatient de voir rapidement certains résultats. Dans tous les cas, vous devriez pouvoir définir la vitesse de consigne et demander à votre logiciel de déplacer la position de coordonnées souhaitée sur le chemin, du début à la fin. Évidemment, vous commencerez avec une faible vitesse souhaitée.

Donc, avant de commencer avec le contrôle, vous devez d'abord parcourir la liste de contrôle suivante:

• Simplifiez votre algorithme de traitement d'image pour obtenir une réponse plus rapide
• Créez un algorithme qui crée une trajectoire sur votre chemin en utilisant une vitesse prédéfinie
• Dans chaque cadre:
  • Calculez la différence entre la trajectoire et la position de la balle
  • Passez la composante delta-X au PID est-ouest, passez le delta-Y au PID nord-sud

Il peut s'avérer préférable de créer la trajectoire un segment à la fois et de continuer avec le segment suivant lorsque cette balle termine le précédent. Sinon, vous devrez vous assurer que le ballon ne dépasse pas la trajectoire souhaitée (ce qui peut être difficile à réaliser)

Si vous avez une position fixe pour la caméra et la lecture mométaire pour les deux axes, vous n'avez pas besoin de reconnaître le chemin peint, les trous et les murs dans les cadres. Cela peut être fait en une seule fois pendant le temps de configuration. Au moment de l'exécution, vous n'aurez peut-être qu'à repérer l'emplacement exact de la seule boule de métal brillant.

Pour repérer la balle, vous pouvez utiliser 1 LED infrarouge à spot fixe et un filtre à bande étroite sur la caméra. L'algorithme doit calculer le pixel le plus lumineux et traduire X, Y en X, Y réel en prenant en compte des étapes comme:

• trouver le pixel le plus lumineux
• utiliser l'angle pour les deux axes (lecture du servo) pour récupérer la distance de la caméra
• utiliser l'horodatage pour la lecture de la position des axes
• appliquer l'interpolation dans le temps pour la lecture de la position si nécessaire
• utiliser une distorsion connue de l'objectif
• traduire le monde X, Y du pixel en angle de réflexion de la sphère parfaite pour trouver le vrai centre de la balle dans le monde X, Y
• temps delta pour récupérer le temps réel de la trame
• interpolation dans le temps de la position dans le plan de bord X, Y si nécessaire
• envoyer le résultat X, Y (t) à l'algorithme PID
• envoyer le deuxième objectif d'alimentation X, Y (t) du générateur / séquence de trajectoire
• laissez PID décider de la sortie
• exécuter la sortie (les dernières étapes peuvent être effectuées en parallèle)

Il ne doit pas être intensif en calcul et dépend principalement de quelques valeurs absolues.

Normalement, un petit processeur devrait le faire avec le rythme du framerate.