Note de l'éditeur: le 16 octobre 2018, cet article a été révisé pour fonctionner avec les dernières technologies.

Regardons les choses en face, les robots sont cool. Ils vont également diriger le monde un jour et, espérons-le, à ce moment-là, ils auront pitié de leurs pauvres créateurs charnus et doux (a.k.a. développeurs de robotique ) et aidez-nous à construire une utopie spatiale remplie d'abondance. Je plaisante bien sûr, mais seulement une sorte de .

Dans mon ambition d'avoir une petite influence sur la question, j'ai pris un cours de théorie du contrôle de robot autonome l'année dernière, qui a abouti à la construction d'un simulateur robotique basé sur Python qui m'a permis de pratiquer la théorie du contrôle sur un robot simple, mobile et programmable.

Dans cet article, je vais montrer comment utiliser un framework de robot Python pour développer un logiciel de contrôle, décrire le schéma de contrôle que j'ai développé pour mon robot simulé, illustrer comment il interagit avec son environnement et atteindre ses objectifs, et discuter de certains des défis fondamentaux de la programmation robotique que j'ai rencontrés en cours de route.

Afin de suivre ce tutoriel sur la programmation robotique pour les débutants, vous devez avoir une connaissance de base de deux choses:

• Mathématiques - nous utiliserons des fonctions trigonométriques et des vecteurs
• Python - puisque Python fait partie des langages de programmation de robot de base les plus populaires - nous utiliserons les bibliothèques et fonctions Python de base

Les extraits de code présentés ici ne sont qu'une partie de l'ensemble du simulateur, qui repose sur des classes et des interfaces.Par conséquent, pour lire le code directement, vous aurez peut-être besoin d'une certaine expérience en Python et programmation orientée objet .

Enfin, les sujets facultatifs qui vous aideront à mieux suivre ce tutoriel sont de savoir ce qu'est une machine à états et comment fonctionnent les capteurs de distance et les encodeurs.

Le défi du robot programmable: perception contre réalité et fragilité du contrôle

Le défi fondamental de toute robotique est le suivant: il est impossible de connaître jamais le véritable état de l'environnement. Le logiciel de contrôle du robot ne peut deviner l'état du monde réel que sur la base des mesures renvoyées par ses capteurs. Il ne peut tenter de changer l'état du monde réel que par la génération de signaux de contrôle.

comment pirater les cartes prépayées

Le logiciel de contrôle du robot ne peut deviner l'état du monde réel que sur la base des mesures renvoyées par ses capteurs.

Ainsi, l'une des premières étapes de la conception des commandes est de proposer une abstraction du monde réel, connue sous le nom de modèle , avec lequel interpréter nos lectures de capteur et prendre des décisions. Tant que le monde réel se comporte selon les hypothèses du modèle, nous pouvons faire de bonnes suppositions et exercer un contrôle. Dès que le monde réel s'écartera de ces hypothèses, cependant, nous ne serons plus en mesure de faire de bonnes suppositions et le contrôle sera perdu. Souvent, une fois le contrôle perdu, il ne peut jamais être retrouvé. (À moins qu'une force extérieure bienveillante ne le rétablisse.)

C'est l'une des principales raisons pour lesquelles la programmation robotique est si difficile. Nous voyons souvent des vidéos du dernier robot de recherche dans le laboratoire, exécutant des exploits fantastiques de dextérité, de navigation ou de travail d'équipe, et nous sommes tentés de demander: «Pourquoi n'est-ce pas utilisé dans le monde réel?» Eh bien, la prochaine fois que vous verrez une telle vidéo, regardez à quel point l'environnement du laboratoire est hautement contrôlé. Dans la plupart des cas, ces robots ne sont capables d'exécuter ces tâches impressionnantes que tant que les conditions environnementales restent dans les limites étroites de son modèle interne. Ainsi, l'une des clés de l'avancement de la robotique est le développement de modèles plus complexes, flexibles et robustes - et ledit avancement est soumis aux limites des ressources de calcul disponibles.

L'une des clés de l'avancement de la robotique est le développement de modèles plus complexes, flexibles et robustes.

[Note latérale: Les philosophes et les psychologues noteraient que les créatures vivantes souffrent également de la dépendance de leur propre perception interne de ce que leurs sens leur disent. De nombreuses avancées en robotique proviennent de l'observation des créatures vivantes et de la façon dont elles réagissent à des stimuli inattendus. Pensez-y. Quel est votre modèle interne du monde? C'est différent de celui d'une fourmi, et de celui d'un poisson? (Avec un peu de chance.) Cependant, comme la fourmi et le poisson, il est susceptible de simplifier à l'extrême certaines réalités du monde. Lorsque vos hypothèses sur le monde ne sont pas correctes, cela peut vous mettre en danger de perdre le contrôle des choses. Parfois, nous appelons cela «danger». De la même manière que notre petit robot lutte pour survivre contre l'univers inconnu, nous aussi. C'est une idée puissante pour les roboticiens.]

Le simulateur de robot programmable

Le simulateur que j'ai construit est écrit en Python et très intelligemment doublé Samedi Rimulator . Vous pouvez trouver la v1.0.0 sur GitHub . Il n'a pas beaucoup de cloches et de sifflets, mais il est conçu pour très bien faire une chose: fournir une simulation précise d'un robot mobile et donner à un robot en herbe un cadre simple pour pratiquer la programmation de logiciels de robot. S'il est toujours préférable d'avoir un vrai robot avec lequel jouer, un bon simulateur de robot Python est beaucoup plus accessible et constitue un excellent point de départ.

Dans les robots du monde réel, le logiciel qui génère les signaux de commande (le «contrôleur») doit fonctionner à une vitesse très élevée et effectuer des calculs complexes. Cela affecte le choix des langages de programmation de robot qu'il est préférable d'utiliser: Habituellement, C ++ est utilisé pour ce type de scénarios, mais dans les applications robotiques plus simples, Python est un très bon compromis entre la vitesse d'exécution et la facilité de développement et de test.

Le logiciel que j'ai écrit simule un robot de recherche réel appelé le Khepera mais il peut être adapté à une gamme de robots mobiles avec différentes dimensions et capteurs. Depuis que j’ai essayé de programmer le simulateur de manière aussi similaire que possible aux capacités du robot réel, la logique de commande peut être chargée dans un vrai robot Khepera avec un minimum de refactorisation, et elle fonctionnera de la même manière que le robot simulé. Les spécificités mises en œuvre se réfèrent au Khepera III, mais elles peuvent être facilement adaptées au nouveau Khepera IV.

En d'autres termes, la programmation d'un robot simulé est analogue à la programmation d'un vrai robot. Ceci est essentiel si le simulateur doit être utile pour développer et évaluer différentes approches logicielles de contrôle.

Dans ce didacticiel, je vais décrire l'architecture du logiciel de contrôle du robot fourni avec la v1.0.0 de Samedi Rimulator , et en fournissant des extraits de la source Python (avec de légères modifications pour plus de clarté). Cependant, je vous encourage à plonger dans la source et à déconner. Le simulateur a été fourchu et utilisé pour contrôler différents robots mobiles, y compris un Roomba2 de je robot . De même, n'hésitez pas à diviser le projet et à l'améliorer.

La logique de contrôle du robot est limitée à ces classes / fichiers Python:

• models/supervisor.py - cette classe est responsable de l'interaction entre le monde simulé autour du robot et le robot lui-même. Il fait évoluer notre machine à états de robot et déclenche les contrôleurs pour calculer le comportement souhaité.
• models/supervisor_state_machine.py - cette classe représente les différents États dans lequel le robot peut être, en fonction de son interprétation des capteurs.
• Les fichiers dans le models/controllers répertoire - ces classes implémentent différents comportements du robot en fonction d'un état connu de l'environnement. En particulier, un contrôleur spécifique est sélectionné en fonction de la machine d'état.

Le but

Les robots, comme les humains, ont besoin d'un but dans la vie. Le but de notre logiciel contrôlant ce robot sera très simple: il tentera de se frayer un chemin vers un point de but prédéterminé. C'est généralement la caractéristique de base que tout robot mobile devrait avoir, des voitures autonomes aux aspirateurs robotiques. Les coordonnées de l'objectif sont programmées dans le logiciel de contrôle avant l'activation du robot mais peuvent être générées à partir d'une application Python supplémentaire qui supervise les mouvements du robot. Par exemple, pensez-y en passant par plusieurs points de cheminement.

Cependant, pour compliquer les choses, l'environnement du robot peut être parsemé d'obstacles. Le robot NE PEUT PAS heurter un obstacle sur son chemin vers le but. Par conséquent, si le robot rencontre un obstacle, il devra trouver son chemin pour pouvoir continuer son chemin vers le but.

Le robot programmable

Chaque robot a des capacités et des problèmes de contrôle différents. Familiarisons-nous avec notre robot programmable simulé.

La première chose à noter est que, dans ce guide, notre robot sera un robot mobile autonome . Cela signifie qu'il se déplacera librement dans l'espace et qu'il le fera sous son propre contrôle. Cela contraste avec, par exemple, un robot télécommandé (qui n'est pas autonome) ou un bras de robot d'usine (qui n'est pas mobile). Notre robot doit trouver par lui-même comment atteindre ses objectifs et survivre dans son environnement. Cela s'avère être un défi étonnamment difficile pour les programmeurs novices en robotique.

Entrées de contrôle: capteurs

Un robot peut être équipé de différentes manières pour surveiller son environnement. Ceux-ci peuvent inclure n'importe quoi, des capteurs de proximité, des capteurs de lumière, des pare-chocs, des caméras, etc. De plus, les robots peuvent communiquer avec des capteurs externes qui leur donnent des informations qu'ils ne peuvent pas eux-mêmes observer directement.

Notre robot de référence est équipé de neuf capteurs infrarouges —Le nouveau modèle a huit capteurs de proximité infrarouges et cinq ultrasons — disposés en «jupe» dans toutes les directions. Il y a plus de capteurs face à l'avant du robot qu'à l'arrière, car il est généralement plus important pour le robot de savoir ce qui se trouve devant lui que ce qui se trouve derrière.

En plus des capteurs de proximité, le robot dispose d'un paire de tickers de roue ce mouvement de roue de piste. Ceux-ci vous permettent de suivre le nombre de rotations effectuées par chaque roue, avec un tour complet en avant d'une roue correspondant à 2765 ticks. Les tours dans la direction opposée comptent à rebours, diminuant le nombre de graduations au lieu de l'augmenter. Vous n’avez pas à vous soucier des nombres spécifiques dans ce didacticiel car le logiciel que nous allons écrire utilise la distance parcourue exprimée en mètres. Plus tard, je vous montrerai comment le calculer à partir de ticks avec une fonction Python simple.

Sorties de contrôle: mobilité

Certains robots se déplacent sur pattes. Certains roulent comme une balle. Certains glissent même comme un serpent.

Notre robot est un entraînement différentiel robot, ce qui signifie qu'il roule sur deux roues. Lorsque les deux roues tournent à la même vitesse, le robot se déplace en ligne droite. Lorsque les roues se déplacent à des vitesses différentes, le robot tourne. Ainsi, maîtriser le mouvement de ce robot revient à bien maîtriser les vitesses de rotation de chacune de ces deux roues.

FEU

Dans Sobot Rimulator, la séparation entre «l'ordinateur» du robot et le monde physique (simulé) est incarnée par le fichier robot_supervisor_interface.py, qui définit l'ensemble de l'API d'interaction avec les capteurs et moteurs du «vrai robot»:

• read_proximity_sensors() renvoie un tableau de neuf valeurs au format natif des capteurs
• read_wheel_encoders() renvoie un tableau de deux valeurs indiquant le total des graduations depuis le début
• set_wheel_drive_rates( v_l, v_r ) prend deux valeurs (en radians par seconde) et définit la vitesse gauche et droite des roues sur ces deux valeurs

Cette interface utilise en interne un objet robot qui fournit les données des capteurs et la possibilité de déplacer des moteurs ou des roues. Si vous souhaitez créer un robot différent, vous devez simplement fournir une classe de robot Python différente qui peut être utilisée par la même interface, et le reste du code (contrôleurs, superviseur et simulateur) fonctionnera immédiatement!

Le simulateur

Comme vous utiliseriez un vrai robot dans le monde réel sans prêter trop d'attention aux lois de la physique impliquées, vous pouvez ignorer la façon dont le robot est simulé et passer directement à la programmation du logiciel du contrôleur, car ce sera presque le même entre le monde réel et une simulation. Mais si vous êtes curieux, je vais vous le présenter brièvement ici.

Le fichier world.py est une classe Python qui représente le monde simulé, avec des robots et des obstacles à l'intérieur. La fonction step à l'intérieur de cette classe s'occupe de faire évoluer notre monde simple en:

• Application de règles physiques aux mouvements du robot
• Considérer les collisions avec des obstacles
• Fournir de nouvelles valeurs pour les capteurs du robot

En fin de compte, il appelle les superviseurs du robot responsables de l'exécution du logiciel du cerveau du robot.

La fonction step est exécutée dans une boucle de sorte que robot.step_motion() déplace le robot en utilisant la vitesse de roue calculée par le superviseur lors de l'étape de simulation précédente.

# step the simulation through one time interval def step( self ): dt = self.dt # step all the robots for robot in self.robots: # step robot motion robot.step_motion( dt ) # apply physics interactions self.physics.apply_physics() # NOTE: The supervisors must run last to ensure they are observing the 'current' world # step all of the supervisors for supervisor in self.supervisors: supervisor.step( dt ) # increment world time self.world_time += dt

Le apply_physics() La fonction met à jour en interne les valeurs des capteurs de proximité du robot afin que le superviseur puisse estimer l'environnement à l'étape de simulation en cours. Les mêmes concepts s'appliquent aux encodeurs.

Un modèle simple

Tout d'abord, notre robot aura un modèle très simple. Il fera de nombreuses hypothèses sur le monde. Certains des plus importants comprennent:

• Le terrain est toujours plat et uniforme
• Les obstacles ne sont jamais ronds
• Les roues ne glissent jamais
• Rien ne va jamais pousser le robot
• Les capteurs ne tombent jamais en panne ou ne donnent jamais de fausses lectures
• Les roues tournent toujours quand on leur dit de

Bien que la plupart de ces hypothèses soient raisonnables dans un environnement semblable à une maison, des obstacles ronds pourraient être présents. Notre logiciel d'évitement d'obstacles a une implémentation simple et suit la frontière des obstacles afin de les contourner. Nous indiquerons aux lecteurs comment améliorer le cadre de contrôle de notre robot avec une vérification supplémentaire pour éviter les obstacles circulaires.

La boucle de contrôle

Nous allons maintenant entrer dans le cœur de notre logiciel de contrôle et expliquer les comportements que nous voulons programmer à l'intérieur du robot. Des comportements supplémentaires peuvent être ajoutés à ce cadre, et vous devriez essayer vos propres idées après avoir fini de lire! Robotique basée sur le comportement Le logiciel a été proposé il y a plus de 20 ans et reste un outil puissant pour la robotique mobile. A titre d'exemple, en 2007 un ensemble de comportements a été utilisé dans le DARPA Urban Challenge - le premier concours de voitures à conduite autonome!

Un robot est un système dynamique. L'état du robot, les lectures de ses capteurs et les effets de ses signaux de commande sont en flux constant. Le contrôle du déroulement des événements implique les trois étapes suivantes:

1. Appliquez des signaux de contrôle.
2. Mesurez les résultats.
3. Générez de nouveaux signaux de contrôle calculés pour nous rapprocher de notre objectif.

Ces étapes sont répétées encore et encore jusqu'à ce que nous ayons atteint notre objectif. Plus nous pouvons faire cela par seconde, plus nous aurons un contrôle précis sur le système. Le robot Sobot Rimulator répète ces étapes 20 fois par seconde (20 Hz), mais de nombreux robots doivent le faire des milliers ou des millions de fois par seconde afin d'avoir un contrôle adéquat. Rappelez-vous notre introduction précédente sur les différents langages de programmation de robot pour différents systèmes robotiques et exigences de vitesse.

En général, chaque fois que notre robot prend des mesures avec ses capteurs, il utilise ces mesures pour mettre à jour son estimation interne de l'état du monde - par exemple, la distance par rapport à son objectif. Il compare cet état à un référence valeur de ce que c'est veut l'état à être (pour la distance, il veut qu'il soit nul), et calcule l'erreur entre l'état souhaité et l'état réel. Une fois cette information connue, la génération de nouveaux signaux de commande peut être réduite à un problème de minimiser l'erreur qui finira par déplacer le robot vers le but.

Une astuce astucieuse: simplifier le modèle

Pour contrôler le robot que nous voulons programmer, nous devons envoyer un signal à la roue gauche lui indiquant à quelle vitesse tourner, et un signal séparé à la roue droite indiquant il à quelle vitesse tourner. Appelons ces signaux v L et v R . Cependant, en pensant constamment en termes de v L et v R est très encombrant. Au lieu de demander: «À quelle vitesse voulons-nous que la roue gauche tourne et à quelle vitesse voulons-nous que la roue droite tourne?» il est plus naturel de se demander: «À quelle vitesse voulons-nous que le robot avance, et à quelle vitesse voulons-nous qu'il tourne ou change de cap?» Appelons ces paramètres vitesse v et vitesse angulaire (rotationnelle) ω (lire «oméga»). Il s'avère que nous pouvons baser l'ensemble de notre modèle sur v et ω au lieu de v L et v R , et seulement une fois que nous avons déterminé comment nous voulons que notre robot programmé se déplace, transforme mathématiquement ces deux valeurs en v L et v R nous devons contrôler les roues du robot. Ceci est connu comme un modèle monocycle de contrôle.

Voici le code Python qui implémente la transformation finale dans supervisor.py. Notez que si ω vaut 0, les deux roues tourneront à la même vitesse:

# generate and send the correct commands to the robot def _send_robot_commands( self ): # ... v_l, v_r = self._uni_to_diff( v, omega ) self.robot.set_wheel_drive_rates( v_l, v_r ) def _uni_to_diff( self, v, omega ): # v = translational velocity (m/s) # omega = angular velocity (rad/s) R = self.robot_wheel_radius L = self.robot_wheel_base_length v_l = ( (2.0 * v) - (omega*L) ) / (2.0 * R) v_r = ( (2.0 * v) + (omega*L) ) / (2.0 * R) return v_l, v_r

Estimation de l'état: robot, connais-toi toi-même

À l'aide de ses capteurs, le robot doit tenter d'estimer l'état de l'environnement ainsi que son propre état. Ces estimations ne seront jamais parfaites, mais elles doivent être assez bonnes car le robot basera toutes ses décisions sur ces estimations. En utilisant uniquement ses capteurs de proximité et ses repères de roue, il doit essayer de deviner ce qui suit:

• La direction des obstacles
• La distance des obstacles
• La position du robot
• La tête du robot

Les deux premières propriétés sont déterminées par les lectures du capteur de proximité et sont assez simples. La fonction API read_proximity_sensors() renvoie un tableau de neuf valeurs, une pour chaque capteur. On sait à l'avance que la septième lecture, par exemple, correspond au capteur qui pointe à 75 degrés à droite du robot.

Ainsi, si cette valeur montre une lecture correspondant à 0,1 mètre de distance, on sait qu'il y a un obstacle à 0,1 mètre, 75 degrés vers la gauche. S'il n'y a pas d'obstacle, le capteur retournera une lecture de sa portée maximale de 0,2 mètre. Ainsi, si nous lisons 0,2 mètre sur le capteur sept, nous supposerons qu'il n'y a en fait aucun obstacle dans cette direction.

En raison du fonctionnement des capteurs infrarouges (mesure de la réflexion infrarouge), les nombres qu'ils renvoient sont une transformation non linéaire de la distance réelle détectée. Ainsi, la fonction Python de détermination de la distance indiquée doit convertir ces lectures en mètres. Ceci est fait dans supervisor.py comme suit:

# update the distances indicated by the proximity sensors def _update_proximity_sensor_distances( self ): self.proximity_sensor_distances = [ 0.02-( log(readval/3960.0) )/30.0 for readval in self.robot.read_proximity_sensors() ]

Encore une fois, nous avons un modèle de capteur spécifique dans ce cadre de robot Python, tandis que dans le monde réel, les capteurs sont livrés avec un logiciel d'accompagnement qui devrait fournir des fonctions de conversion similaires de valeurs non linéaires en mètres.

Déterminer la position et le cap du robot (appelés ensemble pose en programmation robotique) est un peu plus difficile. Notre robot utilise odométrie pour estimer sa pose. C’est là que les tickers de la roue entrent en jeu. En mesurant combien chaque roue a tourné depuis la dernière itération de la boucle de contrôle, il est possible d’obtenir une bonne estimation de la façon dont la pose du robot a changé, mais seulement si le changement est petit .

C'est l'une des raisons pour lesquelles il est important d'itérer la boucle de contrôle très fréquemment dans un robot réel, où les moteurs déplaçant les roues peuvent ne pas être parfaits. Si nous avons attendu trop longtemps pour mesurer les tickers de roue, les deux roues auraient pu faire beaucoup de choses, et il sera impossible d'estimer où nous en sommes arrivés.

Compte tenu de notre simulateur logiciel actuel, nous pouvons nous permettre d'exécuter le calcul d'odométrie à 20 Hz - la même fréquence que les contrôleurs. Mais cela pourrait être une bonne idée d'avoir un thread Python séparé plus rapide pour capturer les petits mouvements des tickers.

Vous trouverez ci-dessous la fonction d'odométrie complète dans supervisor.py qui met à jour l'estimation de la pose du robot. Notez que la pose du robot est composée des coordonnées x et y, et l'en-tête theta, qui est mesuré en radians à partir de l'axe X positif. Positif x est à l'est et positif y est au nord. Ainsi un en-tête de 0 indique que le robot fait face directement à l'est. Le robot suppose toujours que sa pose initiale est (0, 0), 0.

# update the estimated position of the robot using it's wheel encoder readings def _update_odometry( self ): R = self.robot_wheel_radius N = float( self.wheel_encoder_ticks_per_revolution ) # read the wheel encoder values ticks_left, ticks_right = self.robot.read_wheel_encoders() # get the difference in ticks since the last iteration d_ticks_left = ticks_left - self.prev_ticks_left d_ticks_right = ticks_right - self.prev_ticks_right # estimate the wheel movements d_left_wheel = 2*pi*R*( d_ticks_left / N ) d_right_wheel = 2*pi*R*( d_ticks_right / N ) d_center = 0.5 * ( d_left_wheel + d_right_wheel ) # calculate the new pose prev_x, prev_y, prev_theta = self.estimated_pose.scalar_unpack() new_x = prev_x + ( d_center * cos( prev_theta ) ) new_y = prev_y + ( d_center * sin( prev_theta ) ) new_theta = prev_theta + ( ( d_right_wheel - d_left_wheel ) / self.robot_wheel_base_length ) # update the pose estimate with the new values self.estimated_pose.scalar_update( new_x, new_y, new_theta ) # save the current tick count for the next iteration self.prev_ticks_left = ticks_left self.prev_ticks_right = ticks_right

Maintenant que notre robot est capable de générer une bonne estimation du monde réel, utilisons ces informations pour atteindre nos objectifs.

En relation: Tutoriel de physique du jeu vidéo - Détection de collision pour les objets solides

Méthodes de programmation de robot Python: comportement Go-to-Goal

Le but suprême de l’existence de notre petit robot dans ce didacticiel de programmation est d’atteindre le but. Alors, comment faire tourner les roues pour y arriver? Commençons par simplifier un peu notre vision du monde et supposons qu’il n’y a pas d’obstacles sur le chemin.

Cela devient alors une tâche simple et peut être facilement programmé en Python. Si nous avançons face au but, nous y arriverons. Grâce à notre odométrie, nous connaissons nos coordonnées et notre cap actuels. Nous savons également quelles sont les coordonnées de l'objectif car elles ont été préprogrammées. Par conséquent, en utilisant une petite algèbre linéaire, nous pouvons déterminer le vecteur de notre emplacement au but, comme dans go_to_goal_controller.py:

# return a go-to-goal heading vector in the robot's reference frame def calculate_gtg_heading_vector( self ): # get the inverse of the robot's pose robot_inv_pos, robot_inv_theta = self.supervisor.estimated_pose().inverse().vector_unpack() # calculate the goal vector in the robot's reference frame goal = self.supervisor.goal() goal = linalg.rotate_and_translate_vector( goal, robot_inv_theta, robot_inv_pos ) return goal

Notez que nous amenons le vecteur au but dans le cadre de référence du robot , et PAS en coordonnées mondiales. Si l’objectif est sur l’axe X dans le cadre de référence du robot, cela signifie qu’il se trouve directement devant le robot. Ainsi, l'angle de ce vecteur par rapport à l'axe X est la différence entre notre cap et le cap sur lequel nous voulons être. En d'autres termes, c'est le Erreur entre notre état actuel et ce que nous voulons que notre état actuel soit. Nous voulons donc ajuster notre vitesse de rotation ω de sorte que l'angle entre notre cap et l'objectif change vers 0. Nous voulons minimiser l'erreur:

# calculate the error terms theta_d = atan2( self.gtg_heading_vector[1], self.gtg_heading_vector[0] ) # calculate angular velocity omega = self.kP * theta_d

self.kP dans l'extrait de code ci-dessus de l'implémentation Python du contrôleur est un gain de contrôle. C'est un coefficient qui détermine la vitesse à laquelle nous tournons proportion à quelle distance de l'objectif auquel nous sommes confrontés. Si l'erreur dans notre rubrique est 0, alors la vitesse de rotation est également 0. Dans la vraie fonction Python à l'intérieur du fichier go_to_goal_controller.py, vous verrez des gains plus similaires, puisque nous avons utilisé un Contrôleur PID au lieu d'un simple coefficient proportionnel.

Maintenant que nous avons notre vitesse angulaire ω , comment déterminons-nous notre vitesse d'avancement v ? Une bonne règle générale est celle que vous connaissez probablement instinctivement: si nous ne faisons pas de virage, nous pouvons avancer à pleine vitesse, et plus nous tournons vite, plus nous devons ralentir. Cela nous aide généralement à maintenir notre système stable et à agir dans les limites de notre modèle. Donc, v est une fonction de ω . Dans go_to_goal_controller.py l'équation est:

comment voler des numéros de carte de crédit

# calculate translational velocity # velocity is v_max when omega is 0, # drops rapidly to zero as |omega| rises v = self.supervisor.v_max() / ( abs( omega ) + 1 )**0.5

Une suggestion pour développer cette formule est de considérer que nous ralentissons généralement lorsque nous sommes près de l'objectif afin de l'atteindre avec une vitesse nulle. Comment cette formule changerait-elle? Il doit inclure en quelque sorte un remplacement de v_max() avec quelque chose de proportionnel à la distance. OK, nous avons presque terminé une seule boucle de contrôle. Il ne reste plus qu'à transformer ces deux paramètres du modèle monocycle en vitesses de roues différentielles et à envoyer les signaux aux roues. Voici un exemple de la trajectoire du robot sous la manette de destination, sans obstacle:

Comme nous pouvons le voir, le vecteur de l'objectif est une référence efficace sur laquelle baser nos calculs de contrôle. C'est une représentation interne de «là où nous voulons aller». Comme nous le verrons, la seule différence majeure entre les comportements aller au but et les autres comportements est que parfois aller vers l'objectif est une mauvaise idée, nous devons donc calculer un vecteur de référence différent.

Méthodes de programmation du robot Python: comportement d'éviter les obstacles

Aller vers le but quand il y a un obstacle dans cette direction en est un bon exemple. Au lieu de courir tête baissée dans les choses sur notre chemin, essayons de programmer une loi de contrôle qui oblige le robot à les éviter.

Pour simplifier le scénario, oublions maintenant complètement le point d’objectif et faisons de ce qui suit notre objectif: Lorsqu'il n'y a pas d'obstacles devant nous, avancez. Lorsqu'un obstacle est rencontré, éloignez-vous-en jusqu'à ce qu'il ne soit plus devant nous.

Par conséquent, lorsqu'il n'y a pas d'obstacle devant nous, nous voulons que notre vecteur de référence pointe simplement vers l'avant. ensuite ω sera nul et v sera la vitesse maximale. Cependant, dès que nous détectons un obstacle avec nos capteurs de proximité, nous voulons que le vecteur de référence pointe dans n'importe quelle direction éloignée de l'obstacle. Cela causera ω tirer pour nous détourner de l'obstacle, et provoquer v à laisser tomber pour nous assurer que nous ne heurtons pas accidentellement l'obstacle dans le processus.

Un moyen efficace de générer notre vecteur de référence souhaité consiste à transformer nos neuf lectures de proximité en vecteurs et à prendre une somme pondérée. Lorsqu'aucun obstacle n'est détecté, les vecteurs s'additionnent symétriquement, ce qui donne un vecteur de référence qui pointe droit devant vous comme souhaité. Mais si un capteur sur, disons, le côté droit détecte un obstacle, il contribuera à un vecteur plus petit à la somme, et le résultat sera un vecteur de référence qui est décalé vers la gauche.

Pour un robot général avec un placement de capteurs différent, la même idée peut être appliquée mais peut nécessiter des changements de poids et / ou des soins supplémentaires lorsque les capteurs sont symétriques à l'avant et à l'arrière du robot, car la somme pondérée pourrait devenir nulle .

Voici le code qui fait cela dans avoid_obstacles_controller.py:

# sensor gains (weights) self.sensor_gains = [ 1.0+( (0.4*abs(p.theta)) / pi ) for p in supervisor.proximity_sensor_placements() ] # ... # return an obstacle avoidance vector in the robot's reference frame # also returns vectors to detected obstacles in the robot's reference frame def calculate_ao_heading_vector( self ): # initialize vector obstacle_vectors = [ [ 0.0, 0.0 ] ] * len( self.proximity_sensor_placements ) ao_heading_vector = [ 0.0, 0.0 ] # get the distances indicated by the robot's sensor readings sensor_distances = self.supervisor.proximity_sensor_distances() # calculate the position of detected obstacles and find an avoidance vector robot_pos, robot_theta = self.supervisor.estimated_pose().vector_unpack() for i in range( len( sensor_distances ) ): # calculate the position of the obstacle sensor_pos, sensor_theta = self.proximity_sensor_placements[i].vector_unpack() vector = [ sensor_distances[i], 0.0 ] vector = linalg.rotate_and_translate_vector( vector, sensor_theta, sensor_pos ) obstacle_vectors[i] = vector # store the obstacle vectors in the robot's reference frame # accumulate the heading vector within the robot's reference frame ao_heading_vector = linalg.add( ao_heading_vector, linalg.scale( vector, self.sensor_gains[i] ) ) return ao_heading_vector, obstacle_vectors

En utilisant le résultat ao_heading_vector comme référence pour le robot à essayer de faire correspondre, voici les résultats de l'exécution du logiciel du robot en simulation en utilisant uniquement le contrôleur d'éviter les obstacles, en ignorant complètement le point de but. Le robot rebondit sans but, mais il ne heurte jamais un obstacle et parvient même à naviguer dans des espaces très restreints:

Méthodes de programmation de robot Python: automates hybrides (machine à état de comportement)

Jusqu'à présent, nous avons décrit deux comportements - aller au but et éviter les obstacles - de manière isolée. Les deux remplissent admirablement leur fonction, mais pour réussir à atteindre l'objectif dans un environnement plein d'obstacles, nous devons les combiner.

La solution que nous allons développer réside dans une classe de machines qui a la désignation extrêmement cool de automates hybrides . Un automate hybride est programmé avec plusieurs comportements, ou modes différents, ainsi qu'une machine à états de supervision. L'automate de supervision passe d'un mode à un autre en des temps discrets (lorsque les objectifs sont atteints ou que l'environnement a soudainement trop changé), tandis que chaque comportement utilise des capteurs et des roues pour réagir en permanence aux changements d'environnement. La solution s'appelait hybride car il évolue à la fois de manière discrète et continue.

Notre framework de robot Python implémente la machine à états dans le fichier supervisor_state_machine.py.

Equipé de nos deux comportements pratiques, une logique simple se suggère: Lorsqu'aucun obstacle n'est détecté, utilisez le comportement Go-to-Goal. Lorsqu'un obstacle est détecté, passez au comportement Éviter les obstacles jusqu'à ce que l'obstacle ne soit plus détecté.

Il s'avère cependant que cette logique posera de nombreux problèmes. Ce que ce système aura tendance à faire quand il rencontre un obstacle, c'est de s'en détourner, puis dès qu'il s'en est éloigné, de faire demi-tour et de rentrer dedans. Le résultat est une boucle sans fin de commutation rapide qui rend le robot inutile. Dans le pire des cas, le robot peut basculer entre les comportements avec chaque itération de la boucle de contrôle - un état appelé Zeno état .

Il existe plusieurs solutions à ce problème, et les lecteurs qui recherchent des connaissances plus approfondies devraient vérifier, par exemple, l'architecture logicielle DAMN .

Ce dont nous avons besoin pour notre robot simulé simple, c'est une solution plus simple: un comportement de plus spécialisé avec la tâche d'obtenir autour un obstacle et atteindre l'autre côté.

Méthodes de programmation de robot Python: Comportement Follow-Wall

Voici l’idée: lorsque nous rencontrons un obstacle, prenez les deux relevés de capteurs les plus proches de l’obstacle et utilisez-les pour estimer la surface de l’obstacle. Ensuite, définissez simplement notre vecteur de référence pour qu'il soit parallèle à cette surface. Continuez à suivre ce mur jusqu'à ce que A) l'obstacle ne soit plus entre nous et le but, et B) nous sommes plus près du but que nous ne l'étions lorsque nous avons commencé. Ensuite, nous pouvons être certains que nous avons franchi l'obstacle correctement.

Avec nos informations limitées, nous ne pouvons pas dire avec certitude s'il sera plus rapide de contourner l'obstacle vers la gauche ou vers la droite. Pour nous décider, nous sélectionnons la direction qui nous rapprochera immédiatement de l'objectif. Pour déterminer de quelle manière il s'agit, nous devons connaître les vecteurs de référence du comportement aller-au-but et du comportement d'éviter-obstacle, ainsi que les deux vecteurs de référence possibles du mur de suivi. Voici une illustration de la manière dont la décision finale est prise (dans ce cas, le robot choisira d'aller à gauche):

La détermination des vecteurs de référence du mur de suivi s'avère être un peu plus complexe que les vecteurs de référence à éviter ou à atteindre. Jetez un œil au code Python dans follow_wall_controller.py pour voir comment c'est fait.

Conception du contrôle final

La conception du contrôle final utilise le comportement du mur de suivi pour presque toutes les rencontres avec des obstacles. Cependant, si le robot se trouve dans un endroit difficile, dangereusement proche d'une collision, il passera en mode purement d'éviter les obstacles jusqu'à ce qu'il soit à une distance plus sûre, puis retournera au mur de suivi. Une fois que les obstacles ont été négociés avec succès, le robot passe au but. Voici le diagramme d'état final, qui est programmé dans le supervisor_state_machine.py:

Voici le robot qui navigue avec succès dans un environnement encombré à l'aide de ce schéma de contrôle:

Une fonctionnalité supplémentaire de la machine à états que vous pouvez essayer de mettre en œuvre est un moyen d'éviter les obstacles circulaires en passant au but dès que possible au lieu de suivre la frontière d'obstacles jusqu'à la fin (ce qui n'existe pas pour les objets circulaires! )

Tweak, Tweak, Tweak: essai et erreur

Le schéma de contrôle fourni avec Sobot Rimulator est très finement réglé. Il a fallu de nombreuses heures pour peaufiner une petite variable ici, et une autre équation là-bas, pour la faire fonctionner d'une manière dont j'étais satisfait. La programmation robotique implique souvent de nombreux essais et erreurs. Les robots sont très complexes et il y a peu de raccourcis pour les amener à se comporter de manière optimale dans un environnement de simulateur de robot ... du moins, pas grand-chose à court d'apprentissage automatique, mais c'est une toute autre boîte de vers.

La robotique implique souvent de nombreux essais et erreurs.

Je vous encourage à jouer avec les variables de contrôle dans Sobot Rimulator et à observer et à tenter d'interpréter les résultats. Les modifications apportées aux éléments suivants ont toutes des effets profonds sur le comportement du robot simulé:

• Le gain d'erreur kP dans chaque contrôleur
• Les gains du capteur utilisés par le contrôleur d'évitement d'obstacles
• Le calcul de v en tant que fonction de ω dans chaque contrôleur
• La distance d'écartement d'obstacle utilisée par le contrôleur de mur de suivi
• Les conditions de commutation utilisées par supervisor_state_machine.py
• À peu près tout le reste

Lorsque les robots programmables échouent

Nous avons fait beaucoup de travail pour en arriver là, et ce robot semble assez intelligent. Pourtant, si vous exécutez Sobot Rimulator sur plusieurs cartes aléatoires, il ne faudra pas longtemps avant que vous en trouviez une que ce robot ne peut pas gérer. Parfois, il se conduit directement dans les virages serrés et entre en collision. Parfois, il oscille à l'infini du mauvais côté d'un obstacle. Parfois, il est légitimement emprisonné sans chemin possible vers le but. Après tous nos tests et ajustements, nous devons parfois arriver à la conclusion que le modèle avec lequel nous travaillons n'est tout simplement pas à la hauteur et que nous devons changer la conception ou ajouter des fonctionnalités.

Dans l'univers des robots mobiles, le «cerveau» de notre petit robot se situe à l'extrémité la plus simple du spectre. De nombreux cas d'échec rencontrés pourraient être surmontés en ajoutant des logiciels plus avancés au mélange. Des robots plus avancés utilisent des techniques telles que cartographie , pour se souvenir où il a été et éviter d'essayer les mêmes choses encore et encore; heuristique , pour générer des décisions acceptables lorsqu'il n'y a pas de décision parfaite à trouver; et apprentissage automatique , pour régler plus parfaitement les différents paramètres de contrôle régissant le comportement du robot.

Un échantillon de ce qui va arriver

Les robots font déjà beaucoup pour nous, et ils n'en feront plus qu'à l'avenir. Bien que même la programmation de base en robotique soit un domaine d'étude difficile nécessitant une grande patience, c'est aussi un domaine fascinant et extrêmement gratifiant.

Dans ce didacticiel, nous avons appris à développer un logiciel de contrôle réactif pour un robot à l'aide du langage de programmation de haut niveau Python. Mais il existe de nombreux concepts plus avancés qui peuvent être appris et testés rapidement avec un framework de robot Python similaire à celui que nous avons prototypé ici. J'espère que vous envisagerez être impliqué dans la formation des choses à venir!

---

Reconnaissance: Je tiens à remercier Dr. Magnus Egerstedt et Jean-Pierre de la Croix du Georgia Institute of Technology pour m'avoir appris tout cela et pour leur enthousiasme pour mon travail sur Sobot Rimulator.

En relation: Tutoriel OpenCV: Détection d'objets en temps réel à l'aide de MSER sous iOS

Comprendre les bases

Qu'est-ce qu'un robot?

Un robot est une machine avec des capteurs et des composants mécaniques connectés et contrôlés par des cartes électroniques ou des processeurs. Ils traitent les informations et appliquent les changements au monde physique. Les robots sont pour la plupart autonomes et remplacent ou aident les humains dans tout, des routines quotidiennes aux tâches très dangereuses.

À quoi servent les robots?

Les robots sont utilisés dans les usines et les fermes pour effectuer des tâches lourdes ou répétitives. Ils sont utilisés pour explorer les planètes et les océans, nettoyer les maisons et aider les personnes âgées. Les chercheurs et les ingénieurs essaient également d'utiliser des robots dans les situations de catastrophe, l'analyse médicale et la chirurgie. Les voitures autonomes sont aussi des robots!

Comment construisez-vous un robot?

La création d'un robot nécessite plusieurs étapes: la disposition mécanique des pièces, la conception des capteurs et des pilotes, et le développement du logiciel du robot. Habituellement, le corps brut est construit dans les usines et le logiciel est développé et testé sur le premier lot de prototypes fonctionnels.

Comment programmer un robot?

Il y a trois étapes impliquées. Tout d'abord, vous faites fonctionner les moteurs et les capteurs à l'aide de pilotes prêts à l'emploi. Ensuite, vous développez des blocs de construction de base afin de pouvoir déplacer le robot et lire ses capteurs. Enfin, utilisez-le pour développer des routines logicielles intelligentes et complexes afin de créer le comportement souhaité.

Quel est le meilleur langage de programmation pour la robotique?

Deux principaux langages de programmation sont les meilleurs lorsqu'ils sont utilisés en robotique: C ++ et Python, souvent utilisés ensemble car chacun a des avantages et des inconvénients. C ++ est utilisé dans les boucles de contrôle, le traitement d'image et pour interfacer le matériel de bas niveau. Python est utilisé pour gérer des comportements de haut niveau et pour développer rapidement des tests ou des preuves de concepts.

Comment programmer un robot avec Java?

En supposant que vous puissiez exécuter la machine virtuelle Java sur votre robot, vous pouvez interfacer votre code Java avec les pilotes de moteur et de capteur à l'aide de sockets ou de RPC. L'écriture de pilotes de périphériques directement en Java peut être plus difficile que dans d'autres langages tels que C ++, il est donc préférable de se concentrer sur le développement de comportements de haut niveau!

Qu'est-ce que l'ingénierie robotique?

L'ingénierie robotique est un vaste domaine d'ingénierie axé sur la conception et l'intégration de systèmes robotiques entiers. Ainsi, il nécessite une connaissance des systèmes mécaniques, électroniques, logiciels et de contrôle, en interaction avec les ingénieurs spécialisés dans chaque domaine pour répondre aux exigences et aux objectifs d'un robot donné.

Quelle est la différence entre l'automatisation robotique des processus (RPA) et la programmation robotique?

Les deux domaines développent des logiciels afin d'aider ou de remplacer les humains, mais la RPA cible les tâches généralement effectuées par un humain devant un ordinateur, telles que l'envoi d'e-mails, le dépôt de reçus ou la navigation sur un site Web. La robotique exécute plutôt des tâches dans le monde réel telles que le nettoyage, la conduite, la construction ou la fabrication.

Qui a inventé le premier robot au monde?

Le premier robot mobile a été créé en 1966 au Stanford Research Institute par une équipe dirigée par Charles Rosen et Nils Nilsson. Utilisant uniquement un processeur 24 bits et 196 Ko de RAM, il a pu se déplacer dans un bureau de manière autonome tout en évitant les obstacles. Puisqu'il a tremblé pendant qu'il bougeait, leurs créateurs l'ont appelé Shakey.