Aperçu de RobotBuilder

RobotBuilder est une application conçue pour faciliter le processus de développement du robot. RobotBuilder peut vous aider :

  • Générer du code standard.

  • Organisez votre robot et déterminez quels sont ses sous-systèmes clés.

  • Vérifiez que vous avez suffisamment de canaux pour tous vos capteurs et actuateurs.

  • Générer des diagrammes de câblage.

  • Modifiez facilement votre interface opérateur.

  • Plus…

La création d’un programme avec RobotBuilder est une procédure très simple en suivant quelques étapes qui sont les mêmes pour n’importe quel robot. Cette leçon décrit les étapes que vous pouvez suivre. Vous trouverez plus de détails sur chacune de ces étapes dans les sections suivantes du document.

Note

RobotBuilder génère du code à l’aide de la nouvelle infrastructure logicielle orientée commande . Pour plus de détails sur la nouvelle infrastructure logicielle, voir Programmation orientée commande.

Diviser le robot en sous-systèmes

../../../../../_images/robotbuilder-overview-1.png

Votre robot est naturellement composé d’un certain nombre de systèmes plus petits tels que les bases pilotables, les bras, les tireurs, les collectionneurs, les manipulateurs, les poignets articulés, etc. Dans la conception de votre robot, pensez à diviser celui-ci en sous-systèmes plus petits et opérés séparément. Dans cet exemple particulier, il y a un élevateur, un dispositif d’alignement de minibot, une pince, et un système de caméra. Sans oublier la base pilotable. Chacune de ces parties du robot est contrôlée séparément et serait donc de bons candidats pour former les sous-systèmes de ce robot.

Pour plus d’informations, voir Creating a Subsystem.

Ajout de chaque sous-système au projet

../../../../../_images/robotbuilder-overview-2.png

Chaque sous-système sera ajouté au dossier « Subsystems » dans le RobotBuilder et donné un nom significatif. Pour chacun des sous-systèmes, plusieurs attributs sont remplis pour des informations plus précises sur les sous-systèmes. En outre, il existe deux types de sous-systèmes d’intérêt :

  1. PIDSubsystems - souvent il est souhaitable de contrôler l’opération d’un sous-systèmes à l’aide un contrôleur PID. Il s’agit de code dans votre programme qui permet d’amener un paramètre du sous-système, par exemple l’angle du sous-système bras, plus rapidement à une position désirée, puis d’arrêter la rotation lorsque cette position est atteinte. Les sous-systèmes PIDSubsystems ont un code de contrôleur PID intégré et sont souvent plus pratiques à utliser directement plutôt que d’écrire et d’ajouter vous-mêmes du code pour votre contrôleur PID. Les sous-systèmes PIDSubsystems ont un capteur qui détermine quand le dispositif a atteint la position cible et un actionneur (contrôleur de moteur) qui est conduit au point de consigne.

  2. Sous-système régulier - ces sous-systèmes ne disposent pas d’un contrôleur PID intégré et sont utilisés pour les sous-systèmes sans contrôle PID pour la rétroaction ou pour les sous-systèmes nécessitant un contrôle plus complexe que ce qui peut être manipulé avec le contrôleur pid incorporé par défaut.

À mesure que vous avancerez dans la lecture de cette documentation, les différences entre les types de sous-systèmes vous apparaîtront plus évidentes.

Pour plus d’informations, voir Creating a Subsystem and Writing Code for a Subsystem.

Ajout de composants à chacun des sous-systèmes

../../../../../_images/robotbuilder-overview-3.png

Chaque sous-système se compose d’un certain nombre d’actionneurs, de capteurs et de contrôleurs qu’il utilise pour effectuer ses opérations. Ces capteurs et actionneurs sont ajoutés au sous-système auquel ils sont associés. Chacun des capteurs et actionneurs provient de la palette RobotBuilder et est traîné vers le sous-système approprié. Pour chacune d’elles, il y a généralement d’autres propriétés qui doivent être définies, telles que les numéros de port et d’autres paramètres spécifiques au composant.

Dans cet exemple, il y a un sous-système Elevateur qui utilise un moteur et un potentiomètre (moteur et pot) qui ont été déplacés vers le sous-système Elevateur.

Ajout de commandes qui décrivent les objectifs du sous-système

Les commandes constituent les différents objectifs que le robot réalisera. Ces commandes sont ajoutées en faisant glisser la commande sous le dossier « Commands ». Lors de la création d’une commande, il y a 7 choix (indiqués sur la palette à gauche de l’image) :

  • Normal commands - ce sont les commandes les plus flexibles, vous devez écrire tout le code pour effectuer les actions souhaitées et nécessaires pour atteindre l’objectif.

  • Timed commands - ces commandes sont une version simplifiée d’une commande qui se termine après un délai d’attente ou timeout

  • Instant commands - ces commandes sont un version simplifiée d’une commande qui s’exécute pour une itération, puis se termine

  • Command groups - ces commandes sont une combinaison d’autres commandes pouvant s’exécuter aussi bien dans un ordre séquentiel et que parallèle. Vous pouvez les utiliser pour créer des actions plus compliquées à partir d’un certain nombre de commandes de base.

  • Setpoint commands - Les commandes valeur de consigne déplacent un sous-système PID vers une consigne fixe ou l’emplacement souhaité.

  • PID commands - ces commandes ont un contrôleur PID intégré à utiliser avec un sous-système régulier.

  • Conditional commands - ces commandes sélectionnent l’une des deux commandes à exécuter au moment de l’initialisation.

Pour plus d’informations, voir Creating a Command 1 et Writing Command Code.

Tester chaque commande

../../../../../_images/robotbuilder-overview-4.png

Chaque commande peut être exécutée à partir du Shuffleboard ou du SmartDashboard. Ceci est utile pour tester les commandes avant de les ajouter à l’interface de l’opérateur ou à un groupe de commandes. Tant que vous laissez la propriété « Button on SmartDashboard » cochée, un bouton sera créé sur le SmartDashboard. Lorsque vous appuyez sur le bouton de démarrage de la commande, la commande s’exécute et vous pouvez vérifier qu’elle effectue l’action souhaitée.

En créant des boutons, chaque commande peut être testée individuellement. Si toutes les commandes fonctionnent individuellement, vous pouvez être assez sûr que le robot fonctionnera dans son ensemble.

Pour plus d’informations, Test avec Smartdashboard.

Ajout de composants de l’Interface Opérateur

../../../../../_images/robotbuilder-overview-5.png

L’interface Opérateur se compose de joysticks, de gamepads et d’autres dispositifs d’entrée HID. Vous pouvez ajouter des composants d’interface opérateur (joysticks, boutons joystick) à votre programme dans RobotBuilder. Celui-ci générera automatiquement du code qui initialisera tous les composants et leur permettra d’être connectés aux commandes.

Les composants de l’interface Opérateur sont déplacés de la palette vers le dossier »Operator Interface » dans le programme RobotBuilder. D’abord (1) ajouter des joysticks au programme, puis mettre des boutons sous les joysticks associés (2) et leur donner des noms significatifs, comme ShootButton.

Connection des commandes à l’Interface de Opérateur

../../../../../_images/robotbuilder-overview-6.png

Les commandes peuvent être associées à des boutons de sorte que lorsqu’un bouton est appuyé sur la commande est cédulée pour exécution. Cela devrait, pour la plupart du temps, gérer une bonne portion de la partie téléopérée de votre programme de robot.

Cela se fait simplement en ajoutant (1) la commande à l’objet JoystickButton dans le programme RobotBuilder, puis (2) en définissant la condition dans laquelle la commande est planifiée.

Pour plus d’informations, voir Connecting the Operator Interface to a Command.

Développer des commandes autonomes

../../../../../_images/robotbuilder-overview-7.png

Les commandes facilitent le développement de programmes autonomes. Il vous suffit de spécifier quelle commande doit s’exécuter lorsque le robot entre dans la période autonome et elle sera automatiquement planifiée. Si vous avez testé les commandes tel que discuté ci-dessus, il s’agit simplement de choisir la commande qui doit s’exécuter.

Sélectionnez le robot à la racine du projet RobotBuilder (1), puis modifiez la propriété (2) Autonomous Command pour choisir la commande à exécuter. C’est aussi simple que ça !

Pour plus d’informations, voir Setting the Default Autonomous Command.

Générer le code

../../../../../_images/robotbuilder-overview-8.png

À tout moment du processus décrit ci-dessus, RobotBuilder peut vous générer un programme C++ ou Java qui représentera le projet que vous avez créé. Ceci se fait en spécifiant l’emplacement du projet dans les propriétés du projet (1), puis en cliquant sur le bouton de la barre d’outils appropriée pour générer le code (2).

For more information see Generating RobotBuilder Code.