Le widget Mechanism2d

Glass prend en charge l’affichage de représentations en forme de lignes droites des mécanismes de votre robot à l’aide du widget Mechanism2d. Il prend en charge les combinaisons de ligaments qui peuvent tourner et / ou s’étendre ou se rétracter, tels que les bras et les élevateurs et ils peuvent être combinés pour des mécanismes plus compliqués. Une instance de la classe Mechanism2d doit être créée et configuréé, envoyée via NetworkTables et mise à jour périodiquement selon les derniers états du mécanisme dans votre code robot. Il peut également être utilisé avec Simulation physique pour visualiser et programmer les mécanismes de votre robot avant sa construction effective.

Création et configuration de l’instance Mechanism2d

L’objet Mechanism2d est le « canvas » où le mécanisme est dessiné. Le nœud racine est l’endroit où le mécanisme est ancré à Mechanism2d. Pour un seul bras articulé, ce serait le point de pivot. Pour un élevateur, ce serait l’endroit où il est attaché à la base du robot. Pour obtenir un nœud racine (représenté par un objet MechanismRoot2d object), invoquez la méthode getRoot(name, x, y) sur l’objet conteneur Mechanism2d. Le nom est utilisé pour nommer la racine dans NetworkTables et doit être unique, mais n’est pas important. Le système de coordonnées x / y suit la même orientation que Field2d - (0,0) est en bas à gauche.

Dans les exemples ci-dessous, un élevateur est dessiné, avec un poignet rotatif au dessus de celui-ci. L’exemple complet de Mechanism2d est disponible dans Java / C++

43    // the main mechanism object
44    Mechanism2d mech = new Mechanism2d(3, 3);
45    // the mechanism root node
46    MechanismRoot2d root = mech.getRoot("climber", 2, 0);
59  // the main mechanism object
60  frc::Mechanism2d m_mech{3, 3};
61  // the mechanism root node
62  frc::MechanismRoot2d* m_root = m_mech.GetRoot("climber", 2, 0);
32        # the main mechanism object
33        self.mech = wpilib.Mechanism2d(3, 3)
34        # the mechanism root node
35        self.root = self.mech.getRoot("climber", 2, 0)

Chaque objet MechanismLigament2d représente un niveau du mécanisme. Il a trois paramètres requis, un nom, une longueur initiale à dessiner (par rapport à la taille de l’objet Mechanism2d), et un angle initial pour dessiner le ligament en degrés. Les angles des ligaments sont relatifs au ligament parent et suivent une notation mathématique - la même que Rotation2d (dans le sens inverse des aiguilles d’une montre, sens positif). Un ligament basé sur la racine avec un angle de zéro pointera vers la droite. Deux paramètres facultatifs vous permettent de modifier la largeur (également par rapport à la taille de l’objet Mechanism2d) et la couleur. Invoquez append()/Append() sur un nœud racine ou un nœud de ligament pour ajouter un autre nœud à la figure. En Java, passez un objet MechanismLigament2d déjà construit pour l’ajouter. En C++, passez les paramètres de construction afin de construire et d’ajouter un ligament.

48    // MechanismLigament2d objects represent each "section"/"stage" of the mechanism, and are based
49    // off the root node or another ligament object
50    m_elevator = root.append(new MechanismLigament2d("elevator", kElevatorMinimumLength, 90));
51    m_wrist =
52        m_elevator.append(
53            new MechanismLigament2d("wrist", 0.5, 90, 6, new Color8Bit(Color.kPurple)));
63  // MechanismLigament2d objects represent each "section"/"stage" of the
64  // mechanism, and are based off the root node or another ligament object
65  frc::MechanismLigament2d* m_elevator =
66      m_root->Append<frc::MechanismLigament2d>("elevator", 1, 90_deg);
67  frc::MechanismLigament2d* m_wrist =
68      m_elevator->Append<frc::MechanismLigament2d>(
69          "wrist", 0.5, 90_deg, 6, frc::Color8Bit{frc::Color::kPurple});
37        # MechanismLigament2d objects represent each "section"/"stage" of the mechanism, and are based
38        # off the root node or another ligament object
39        self.elevator = self.root.appendLigament(
40            "elevator", self.kElevatorMinimumLength, 90
41        )
42        self.wrist = self.elevator.appendLigament(
43            "wrist", 0.5, 90, 6, wpilib.Color8Bit(wpilib.Color.kPurple)
44        )

Ensuite, publiez l’objet Mechanism2d sur NetworkTables :

55    // post the mechanism to the dashboard
56    SmartDashboard.putData("Mech2d", mech);
36    // publish to dashboard
37    frc::SmartDashboard::PutData("Mech2d", &m_mech);
46        # post the mechanism to the dashboard
47        wpilib.SmartDashboard.putData("Mech2d", self.mech)

Note

L’instance Mechanism2d peut également être envoyée à l’aide d’une API NetworkTables de bas niveau ou à l’aide de l’API Shuffleboard API. Dans ce cas, l’API SmartDashboard a été utilisée, ce qui signifie que le widget Mechanism2d apparaîtra sous le nom de la table SmartDashboard.

Pour manipuler un angle ou une longueur de ligament, invoquer setLength() ou setAngle() sur l’objet MechanismLigament2d. Lorsque vous manipulez la longueur des ligaments en fonction des mesures du capteur, assurez-vous d’ajouter la longueur minimale pour éviter les ligaments de longueur 0 (et donc invisibles).

59  @Override
60  public void robotPeriodic() {
61    // update the dashboard mechanism's state
62    m_elevator.setLength(kElevatorMinimumLength + m_elevatorEncoder.getDistance());
63    m_wrist.setAngle(m_wristPot.get());
64  }
40  void RobotPeriodic() override {
41    // update the dashboard mechanism's state
42    m_elevator->SetLength(kElevatorMinimumLength +
43                          m_elevatorEncoder.GetDistance());
44    m_wrist->SetAngle(units::degree_t{m_wristPotentiometer.Get()});
45  }
49    def robotPeriodic(self):
50        # update the dashboard mechanism's state
51        self.elevator.setLength(
52            self.kElevatorMinimumLength + self.elevatorEncoder.getDistance()
53        )
54        self.wrist.setAngle(self.wristPot.get())

Affichage de Mechanism2d sous Glass

Après avoir envoyé l’instance Mechanism2d à traver NetworkTables, le widget Mechanism2d peut être ajouté à Glass en sélectionnant NetworkTables dans la barre de menus, en choisissant le nom de la table sur laquelle l’instance a été envoyée, puis en cliquant sur le bouton Field.

../../../../_images/select-mechanism2d.png

Une fois que le widget apparaît comme indiqué ci-dessous, vous pouvez le redimensionner et le placer sur l’espace de travail Glass comme vous le souhaitez. Un cliquant sur le bouton droit sur le haut du widget, vous pouver personnaliser le nom du widget. Au fur et à mesure que le potentiomètre du poignet et l’encodeur de l’élevateur changent, les paramètres du mécanisme se mettent à jour dans le widget.

../../../../_images/mechanism2d-widget.png

Viewing the Mechanism2d in AdvantageScope

AdvantageScope is an alternative option for viewing a Mechanism2d object, including data recorded to a log file using WPILib data logs. Both 2D and 3D visualizations are supported. See the documentation for the mechanism and 3D field tabs for more details.

Screenshot of an AdvantageScope window displaying a robot and mechanism in 3D.

Prochaines étapes

As mentioned above, the Mechanism2d visualization can be combined with Physics Simulation to help you program mechanisms before your robot is built. The ArmSimulation (Java / C++ / Python) and ElevatorSimulation (Java / C++ / Python) examples combine physics simulation and Mechanism2d visualization so that you can practice programming a single jointed arm and elevator without a robot.