Gyroscopes - Partie logicielle

Note

Cette section couvre le logiciel associé aux gyroscopes. Pour un guide sur le branchement électrique des gyroscopes, consulter Gyroscopes.

Un gyroscope, ou «gyro», est un capteur de vitesse angulaire généralement utilisé en robotique pour mesurer et/ou stabiliser le cap (direction angulaire souhaitée) d’un robot. WPILib fournit un support spécifique pour le gyroscope ADXRS450 disponible dans le kit de pièces, ainsi qu’un support plus général pour une plus grande variété de gyroscopes analogiques via la classe AnalogGyro.

L’interface Gyro

Tous les objets gyro nativement pris en charge par WPILib implémentent l’interface Gyro (Java, C++). Cette interface fournit des méthodes pour obtenir le taux angulaire actuel et la position angulaire, la mise à zéro de la position angulaire actuelle, et le calibrage du gyro.

Note

Il est primordial que le robot reste immobile pendant l’étalonnage d’un gyroscope.

ADXRS450_Gyro

La classe ADXRS450_Gyro (Java, C++) fournit une prise en charge pour le gyroscope Analog Devices ADXRS450 disponible dans le kit de pièces, qui se connecte sur le bus SPI.

Note

L’accumulation des données du gyroscope ADXRS450 est gérée par des circuits spéciaux dans le FPGA; en conséquence, une seule instance de ADXRS450_Gyro peut être utilisée.

// Creates an ADXRS450_Gyro object on the MXP SPI port
Gyro gyro = new ADXRS450_Gyro(SPI.Port.kMXP);

AnalogGyro

La classe AnalogGyro (Java, C++) fournit un support pour tout gyroscope à axe unique pourvue d’une sortie analogique.

Note

L’accumulation des données du gyroscope est gérée par des circuits spéciaux dans le FPGA; en conséquence, AnalogGyro`s ne peut être utilisé que sur les ports analogiques 0 et 1.

// Creates an AnalogGyro object on port 0
Gyro gyro = new AnalogGyro(0);

Gyroscopes tiers

Alors que WPILib fournit un support natif pour un gyroscope ADXRS450 disponible dans le kit de pièces et pour tout gyroscope analogique, il existe quelques dispositifs AHRS (Attitude and Heading Reference System) couramment utilisés dans FRC | reg | qui comprennent des accéléromètres et nécessitent des communications plus complexes. Ceux-ci sont généralement contrôlés par les bibliothèques des fournisseurs.

Utilisation de gyroscopes dans le code

Note

Comme les gyroscopes mesurent le taux (variation) plutôt que la position angulaire, la position est calculée en intégrant (additionnant) les taux pour obtenir la valeur d’angle actuel. Par conséquant, les mesures d’angle gyroscopique sont toujours relatives à un angle zéro arbitraire (déterminé par l’angle du gyroscope lorsque le robot est mis en marche ou lorsqu’une méthode de mise à zéro a été appelée). Ces mesures sont également sujettes à des erreurs accumulées (appelées « dérives ») qui vont en s’augmentant, au fur et à mesure que le gyroscope est utilisé. La quantité de dérive varie selon le type de gyroscope.

Les gyroscopes sont extrêmement utiles en FRC pour mesurer et contrôler le cap du robot. Étant donné que les jeux FRC sont de courte durée (moins de 3 minutes), la dérive totale du gyroscope au cours d’un jeu FRC a tendance à être gérable (de l’ordre de quelques degrés pour un gyroscope de bonne qualité). De plus, ce ne sont pas toutes les applications gyroscopiques qui nécessitent que la mesure du cap reste précise tout au long du jeu.

Affichage du cap du robot sur le tableau de bord

Shuffleboard inclut un widget pour afficher les données de cap à partir d’un Gyro sous la forme d’une boussole. Cela peut être utile pour visualiser le cap du robot lorsque le champ de vision du pilote est gêné par des objets sur le terrain:

Gyro gyro = new ADXRS450_Gyro(SPI.Port.kMXP);

public void robotInit() {
    // Places a compass indicator for the gyro heading on the dashboard
    // Explicit down-cast required because Gyro does not extend Sendable
    Shuffleboard.getTab("Example tab").add((Sendable) gyro);
}

Stabilisation du cap pendant la conduite

Une utilisation très courante d’un gyroscope est de stabiliser le cap du robot pendant la conduite, de sorte que le robot roule en ligne droite. Ceci est particulièrement important pour les entraînements holonomiques tels que Mécanum et Swerve, mais aussi utile pour les entraînements différentiels, style « char d’assaut ».

Ceci est généralement réalisé en utilisant une boucle de contrôle PID axée sur la vitesse de rotation angulaire ou le cap du robot. La sortie de cette boucle est dirigée vers les contrôleurs de moteurs, et le code génère alors un léger différentiel de vitesse entre les deux côtés de l’entraînement (gauche et droite) afin de corriger le cap du robot. Pour les robots avec Mécanum ou Swerve, cette correction de cap est gérée de façon différente.

Avertissement

Comme pour toutes les boucles de contrôle, les utilisateurs doivent veiller à ce que la direction du capteur et la direction de rotation soient cohérentes. Si ce n’est pas le cas, la boucle sera instable et le robot pivotera autour de son axe central de manière incontrôlée.

Exemple: stabilisation de l’entraînement de type différentiel à l’aide du taux de rotation

L’exemple suivant montre comment stabiliser le cap à l’aide d’une simple boucle P axée sur le taux de rotation angulaire. Étant donné qu’un robot qui ne tourne pas devrait avoir un taux de rotation égal à zéro, le point de consigne pour la boucle est implicitement nul, ce qui rend cette méthode très simple.

Gyro gyro = new ADXRS450_Gyro(SPI.Port.kMXP);

// The gain for a simple P loop
double kP = 1;

// Initialize motor controllers and drive
Spark left1 = new Spark(0);
Spark left2 = new Spark(1);

Spark right1 = new Spark(2);
Spark right2 = new Spark(3);

SpeedControllerGroup leftMotors = new SpeedControllerGroup(left1, left2);
SpeedControllerGroup rightMotors = new SpeedControllerGroup(right1, right2);

DifferentialDrive drive = new DifferentialDrive(leftMotors, rightMotors);

@Override
public void autonomousPeriodic() {
    // Setpoint is implicitly 0, since we don't want the heading to change
    double error = -gyro.getRate();

    // Drives forward continuously at half speed, using the gyro to stabilize the heading
    drive.tankDrive(.5 + kP * error, .5 - kP * error);
}

D’autres implémentations plus avancées peuvent utiliser une boucle de contrôle plus complexe. Les boucles PI sont particulièrement efficaces pour l’autorégulation de la direction basée sur le taux de rotation angulaire.

Exemple: stabilisation de l’entraînement du réservoir à l’aide du cap

L’exemple suivant montre comment stabiliser le cap à l’aide d’une simple boucle P axée sur le cap. Contrairement à l’exemple précédent, nous devrons régler le point de consigne sur le cap actuel du robot avant de commencer le mouvement, ce qui rend cette méthode légèrement plus compliquée.

Gyro gyro = new ADXRS450_Gyro(SPI.Port.kMXP);

// The gain for a simple P loop
double kP = 1;

// The heading of the robot when starting the motion
double heading;

// Initialize motor controllers and drive
Spark left1 = new Spark(0);
Spark left2 = new Spark(1);

Spark right1 = new Spark(2);
Spark right2 = new Spark(3);

SpeedControllerGroup leftMotors = new SpeedControllerGroup(left1, left2);
SpeedControllerGroup rightMotors = new SpeedControllerGroup(right1, right2);

DifferentialDrive drive = new DifferentialDrive(leftMotors, rightMotors);

@Override
public void autonomousInit() {
    // Set setpoint to current heading at start of auto
    heading = gyro.getAngle();
}

@Override
public void autonomousPeriodic() {
    double error = heading - gyro.getAngle();

    // Drives forward continuously at half speed, using the gyro to stabilize the heading
    drive.tankDrive(.5 + kP * error, .5 - kP * error);
}

Les implémentations plus avancées peuvent utiliser une boucle de contrôle plus complexe. Les boucles PD sont particulièrement efficaces pour l’autorégulation de la direction basée sur le cap.

Rotation vers un cap défini

Une autre application courante et très utile pour un gyroscope consiste à faire tourner le robot pour qu’il pointe vers une direction spécifiée. Cela peut être utile lors de la période de conduite autonome, ou encore, pendant le contrôle téléopéré pour aider à aligner le robot avec un élément du terrain de jeu.

Tout comme avec la stabilisation de cap, ceci est accompli avec une boucle PID - contrairement à la stabilisation, la boucle doit être axée sur le cap uniquement. L’exemple de code suivant fera tourner le robot de 90 degrés avec une simple boucle P:

Gyro gyro = new ADXRS450_Gyro(SPI.Port.kMXP);

// The gain for a simple P loop
double kP = 1;

// Initialize motor controllers and drive
Spark left1 = new Spark(0);
Spark left2 = new Spark(1);

Spark right1 = new Spark(2);
Spark right2 = new Spark(3);

SpeedControllerGroup leftMotors = new SpeedControllerGroup(left1, left2);
SpeedControllerGroup rightMotors = new SpeedControllerGroup(right1, right2);

DifferentialDrive drive = new DifferentialDrive(leftMotors, rightMotors);

@Override
public void autonomousPeriodic() {
    // Find the heading error; setpoint is 90
    double error = 90 - gyro.getAngle();

    // Turns the robot to face the desired direction
    drive.tankDrive(kP * error, kP * error);
}

Comme précédemment, les implémentations plus avancées peuvent utiliser des boucles de contrôle plus compliquées.

Note

Les boucles de rotation à angle peuvent être difficiles à régler correctement en raison de la force de friction existante dans la transmission, surtout si une simple boucle P est utilisée. Il existe plusieurs façons de contrebalancer cela; l’une des plus courantes/efficaces consiste à ajouter une valeur de « sortie minimale » à la sortie de la boucle de contrôle. Une autre stratégie efficace consiste à pré-régler les contrôleurs de vitesse pour chaque moteur, sur chaque côté du robot.