Compteurs - Partie logicielle

The Counter class (Java, C++) is a versatile class that allows the counting of pulse edges on a digital input. Counter is used as a component in several more-complicated WPILib classes (such as Encoder and Ultrasonic), but is also quite useful on its own.

Note

Il y a un total de 8 dispositifs de type « compteur » dans le roboRIO FPGA, ce qui signifie pas plus de 8 objets Counter peuvent être instanciés à tout moment, y compris ceux contenus comme ressources dans d’autres objets WPILib. Pour des informations détaillées sur quand un: code:Counter peut être utilisé par un autre objet, reportez-vous à la documentation officielle de l’API.

Configuration d’un compteur

La classe Counter peut être configurée de différentes manières pour fournir des fonctionnalités différentes.

Modes de l’objet Counter

L’objet Counter peut être configuré pour fonctionner dans l’un des quatre modes différents:

1. Two-pulse mode: compte de haut en bas en fonction des fronts de deux canaux différents.

2. Semi-period mode: mesure la durée d’une impulsion sur un seul canal.

3. Mode de longueur d’impulsion: compte en haut et en bas en fonction des bords d’un canal, la direction étant déterminée par la durée de l’impulsion sur ce canal.

4. External direction mode: compte vers le haut et vers le bas en fonction des fronts d’un canal. Un autre canal séparé spécifie la direction.

Note

In all modes except semi-period mode, the counter can be configured to increment either once per edge (2X decoding), or once per pulse (1X decoding). By default, counters are set to two-pulse mode, though if only one channel is specified the counter will only count up.

Mode deux-impulsions (« Two-pulse mode »)

En mode deux-impulsions , le Counter comptera vers le haut pour chaque front / impulsion sur le « canal montant » spécifié et vers le bas pour chaque front / impulsion sur le « “canal descendant » spécifié. Un compteur peut être initialisé en deux impulsions avec le code suivant:

JAVA

// Create a new Counter object in two-pulse mode
Counter counter = new Counter(Counter.Mode.k2Pulse);

public Robot() {
    // Set up the input channels for the counter
    counter.setUpSource(1);
    counter.setDownSource(2);
    // Set the decoding type to 2X
    counter.setUpSourceEdge(true, true);
    counter.setDownSourceEdge(true, true);
}

C++

// Create a new Counter object in two-pulse mode
frc::Counter counter{frc::Counter::Mode::k2Pulse};
Robot::Robot() {
    // Set up the input channels for the counter
    counter.SetUpSource(1);
    counter.SetDownSource(2);
    // Set the decoding type to 2X
    counter.SetUpSourceEdge(true, true);
    counter.SetDownSourceEdge(true, true);

Mode demi-période (« Semi-period mode »)

En mode demi-période, le Counter comptera la durée des impulsions sur un canal, soit d’un front montant au front descendant suivant, soit d’un front descendant au front montant suivant. Un compteur peut être initialisé en mode demi-période avec le code suivant:

JAVA

// Create a new Counter object in two-pulse mode
Counter counter = new Counter(Counter.Mode.kSemiperiod);

public Robot() {
    // Set up the input channel for the counter
    counter.setUpSource(1);
    // Set the encoder to count pulse duration from rising edge to falling edge
    counter.setSemiPeriodMode(true);
}

C++

// Create a new Counter object in two-pulse mode
frc::Counter counter{frc::Counter::Mode::kSemiperiod};
void Robot() {
    // Set up the input channel for the counter
    counter.SetUpSource(1);
    // Set the encoder to count pulse duration from rising edge to falling edge
    counter.SetSemiPeriodMode(true);

Pour obtenir la largeur d’impulsion, appelez la méthode getPeriod ():

JAVA

// Return the measured pulse width in seconds
counter.getPeriod();

C++

// Return the measured pulse width in seconds
counter.GetPeriod();

Mode durée d’impulsion (« Pulse-length mode »)

En mode durée d’impulsion, le compteur comptera vers le haut ou vers le bas selon la durée de l’impulsion. Une impulsion au-dessous du temps seuil spécifié sera interprétée comme un compte vers le haut et une impulsion au-dessus du seuil est un compte vers le bas. (Notez l’inversion logique). Ceci est utile pour certains capteurs qui codent la direction de cette manière, comme ceux qui mesurent la position sur les dents d’un engrenage . Un compteur peut être initialisé dans ce mode comme suit:

JAVA

// Create a new Counter object in two-pulse mode
Counter counter = new Counter(Counter.Mode.kPulseLength);

public Robot() {
    // Set up the input channel for the counter
    counter.setUpSource(1);
    // Set the decoding type to 2X
    counter.setUpSourceEdge(true, true);
    // Set the counter to count down if the pulses are longer than .05 seconds
    counter.setPulseLengthMode(.05)
}

C++

// Create a new Counter object in two-pulse mode
frc::Counter counter{frc::Counter::Mode::kPulseLength};
Robot::Robot() {
    // Set up the input channel for the counter
    counter.SetUpSource(1);
    // Set the decoding type to 2X
    counter.SetUpSourceEdge(true, true);
    // Set the counter to count down if the pulses are longer than .05 seconds
    counter.SetPulseLengthMode(.05)

Mode direction externe (« External direction mode »)

In external direction mode, the counter counts either up or down depending on the level on the second channel. If the direction source is low, the counter will increase; if the direction source is high, the counter will decrease (to reverse this, see the next section). A counter can be initialized in this mode as follows:

JAVA

// Create a new Counter object in two-pulse mode
Counter counter = new Counter(Counter.Mode.kExternalDirection);

public Robot() {
    // Set up the input channels for the counter
    counter.setUpSource(1);
    counter.setDownSource(2);
    // Set the decoding type to 2X
    counter.setUpSourceEdge(true, true);
}

C++

// Create a new Counter object in two-pulse mode
frc::Counter counter{frc::Counter::Mode::kExternalDirection};
void RobotInit() {
    // Set up the input channels for the counter
    counter.SetUpSource(1);
    counter.SetDownSource(2);
    // Set the decoding type to 2X
    counter.SetUpSourceEdge(true, true);

Configuration des paramètres des compteurs

Note

La classe Counter ne fait aucune hypothèse sur les unités de distance; comme elle compte seulement les impulsions, elle retournera les valeurs dans le système d’unités utilisées pour calculer la distance. Les utilisateurs ont ainsi un contrôle total sur les unités de distance utilisées. Cependant, les unités de temps sont toujours en secondes.

Note

Le nombre d’impulsions utilisé dans le calcul de la distance par impulsion ne dépend pas du type de décodage - chaque « impulsion » doit toujours être considérée comme un cycle complet (montant et descendant).

Outre les configurations spécifiques au mode, la classe Counter propose un certain nombre de méthodes de configuration supplémentaires:

JAVA

// Configures the counter to return a distance of 4 for every 256 pulses
// Also changes the units of getRate
counter.setDistancePerPulse(4./256.);
// Configures the counter to consider itself stopped after .1 seconds
counter.setMaxPeriod(.1);
// Configures the counter to consider itself stopped when its rate is below 10
counter.setMinRate(10);
// Reverses the direction of the counter
counter.setReverseDirection(true);
// Configures an counter to average its period measurement over 5 samples
// Can be between 1 and 127 samples
counter.setSamplesToAverage(5);

C++

// Configures the counter to return a distance of 4 for every 256 pulses
// Also changes the units of getRate
counter.SetDistancePerPulse(4./256.);
// Configures the counter to consider itself stopped after .1 seconds
counter.SetMaxPeriod(.1);
// Configures the counter to consider itself stopped when its rate is below 10
counter.SetMinRate(10);
// Reverses the direction of the counter
counter.SetReverseDirection(true);
// Configures an counter to average its period measurement over 5 samples
// Can be between 1 and 127 samples
counter.SetSamplesToAverage(5);

Lecture des informations des compteurs

Quel que soit le mode, il existe des informations que la classe Counter rend toujours disponibles aux utilisateurs:

Le compte

Les utilisateurs peuvent obtenir le compte actuel avec la méthode get():

JAVA

// returns the current count
counter.get();

C++

// returns the current count
counter.Get();

La distance

Note

Les compteurs mesurent la distance relative, pas absolue ; la valeur de distance renvoyée dépendra de la position de l’encodeur lorsque le robot a été allumé ou la dernière valeur de l’encodeur reset.

Si la distance par impulsion a été configurée, les utilisateurs peuvent obtenir la distance totale parcourue par le capteur compté avec la méthode getDistance( ) :

JAVA

// returns the current distance
counter.getDistance();

C++

// returns the current distance
counter.GetDistance();

Le taux

Note

Les unités de temps pour la classe Counter sont toujours en secondes.

Les utilisateurs peuvent obtenir le taux de changement actuel du compteur avec la méthode getRate() :

JAVA

// Gets the current rate of the counter
counter.getRate();

C++

// Gets the current rate of the counter
counter.GetRate();

Mode stationnaire

Les utilisateurs peuvent savoir si le compteur est stationnaire avec la méthode getStopped():

JAVA

// Gets whether the counter is stopped
counter.getStopped();

C++

// Gets whether the counter is stopped
counter.GetStopped();

La direction

Les utilisateurs peuvent obtenir la direction vers laquelle le compteur incrémente ou décrémente avec le code:

JAVA

// Gets the last direction in which the counter moved
counter.getDirection();

C++

// Gets the last direction in which the counter moved
counter.GetDirection();

La période

Note

Dans le mode semi-période, cette méthode renvoie la durée de l’impulsion, pas de la période.

Les utilisateurs peuvent obtenir la durée (en secondes) de la période la plus récente avec la méthode getPeriod():

JAVA

// returns the current period in seconds
counter.getPeriod();

C++

// returns the current period in seconds
counter.GetPeriod();

Réinitialisation d’un compteur

Pour réinitialiser un compteur à une lecture de distance de zéro, appelez la méthode reset(). Ceci est utile pour garantir que la distance mesurée correspond à la mesure physique réelle souhaitée.

JAVA

// Resets the encoder to read a distance of zero
counter.reset();

C++

// Resets the encoder to read a distance of zero
counter.Reset();

Utilisation de compteurs dans le code

Les compteurs sont utiles pour une grande variété d’applications robotiques - mais comme la classe Counter est si variée, il est difficile d’en fournir un bon résumé ici. Beaucoup de ces applications se chevauchent avec la classe Encoder - un simple compteur est souvent une alternative moins chère à un encodeur en quadrature. Pour un résumé des utilisations potentielles des encodeurs dans le code, voir Encodeurs - Partie logicielle.