Entrées analogiques - Partie logicielle

Note

Cette section couvre le logiciel associé aux entrées analogiques. Pour un guide sur le branchement électrique aux entrées analogiques, voir Entrées analogiques.

Le FPGA du roboRIO prend en charge jusqu’à 8 canaux d’entrée analogiques qui peuvent être utilisés pour lire la valeur d’une tension analogique à partir d’un capteur. Les entrées analogiques peuvent être utilisées pour tout capteur qui produit une tension simple.

Les entrées analogiques du FPGA retournent par défaut un entier de 12 bits proportionnel à la tension, de 0 à 5 volts.

La classe AnalogInput

Note

Il est souvent plus pratique d’utiliser la classe wrapper Potentiomètres analogiques que d’utiliser AnalogInput directement, car elle supporte la mise à l’échelle en unités significatives.

Support for reading the voltages on the FPGA analog inputs is provided through the AnalogInput class (Java, C++).

Initialisation d’une entrée analogique

Un AnalogInput peut être initialisé comme suit:

// Initializes an AnalogInput on port 0
AnalogInput analog = new AnalogInput(0);

// Initializes an AnalogInput on port 0
frc::AnalogInput analog{0};

Suréchantillonnage et moyenne

Le convertisseur analogique-numérique lit le signal et le transmet au suréchantillonnage, à la moyenne et à un accumulateur.

Les modules d’entrée analogique du FPGA prennent en charge à la fois le suréchantillonnage et la moyenne. Ces comportements sont très similaires, mais diffèrent de plusieurs façons importantes. Les deux peuvent être utilisés en même temps.

Suréchantillonnage

Lorsque le suréchantillonnage est activé, le FPGA additionne ensemble plusieurs échantillons consécutifs et renvoie la valeur cumulée. Les utilisateurs peuvent spécifier le nombre de bits de suréchantillonnage - pour \(n\) bits de suréchantillonnage, le nombre d’échantillons additionnés est \(2^{n}\):

// Sets the AnalogInput to 4-bit oversampling.  16 samples will be added together.
// Thus, the reported values will increase by about a factor of 16, and the update
// rate will decrease by a similar amount.
analog.setOversampleBits(4);

// Sets the AnalogInput to 4-bit oversampling.  16 samples will be added together.
// Thus, the reported values will increase by about a factor of 16, and the update
// rate will decrease by a similar amount.
analog.SetOversampleBits(4);

Moyenne

La moyenne se comporte comme un suréchantillonnage, sauf que les valeurs accumulées sont divisées par le nombre d’échantillons de sorte que la mise à l’échelle des valeurs renvoyées ne change pas. C’est souvent plus pratique, mais parfois l’erreur d’arrondi supplémentaire introduite par l’arrondi n’est pas souhaitable.

// Sets the AnalogInput to 4-bit averaging.  16 samples will be averaged together.
// The update rate will decrease by a factor of 16.
analog.setAverageBits(4);

// Sets the AnalogInput to 4-bit averaging.  16 samples will be averaged together.
// The update rate will decrease by a factor of 16.
analog.SetAverageBits(4);

Note

Lorsque le suréchantillonnage et la moyenne sont utilisés en même temps, le suréchantillonnage est appliqué en premier, puis la moyenne est calculée sur les valeurs suréchantillonnées. Ainsi, un suréchantillonnage à 2 bits et une moyenne à 2 bits utilisés en même temps augmenteront l’échelle des valeurs renvoyées par approximativement un facteur de 2, mais par contre, réduiront le taux de mise à jour par un facteur de 4.

Lecture des valeurs à partir d’une entrée analogique

Les valeurs peuvent être lues à partir d’une entrée analogique en utilisant une des quatre méthodes suivantes:

getValue

La méthode getValue renvoie la valeur instantanée mesurée à l’entrée analogique, sans appliquer d’étalonnage et en ignorant les paramètres de suréchantillonnage et de moyenne. La valeur renvoyée est un entier.

analog.getValue();

analog.GetValue();

getVoltage

La méthode getVoltage renvoie la tension instantanée mesurée à l” l’entrée analogique. Les paramètres de suréchantillonnage et de moyenne sont ignorés, mais la valeur est redimensionnée pour représenter une tension. La valeur renvoyée est un double.

analog.getVoltage();

analog.GetVoltage();

getAverageValue

La méthode getAverageValue renvoie la valeur moyenne de l’entrée analogique. La valeur n’est pas redimensionnée, mais un suréchantillonnage et une moyenne sont tous deux appliqués. La valeur renvoyée est un entier.

analog.getAverageValue();

analog.GetAverageValue();

getAverageVoltage

La méthode getAverageVoltage renvoie la tension moyenne de l’entrée analogique. Le redimensionnement, le suréchantillonnage et la moyenne sont tous appliqués. La valeur renvoyée est un double.

analog.getAverageVoltage();

analog.GetAverageVoltage();

Accumulateur

Note

Les méthodes d’accumulateur ne prennent actuellement pas en charge le retour d’une valeur en unités de volts - la valeur retournée sera toujours un entier (en particulier, un long).

Les canaux d’entrée analogique 0 et 1 prennent également en charge un accumulateur qui intègre (additionne) le signal indéfiniment, de sorte que la valeur renvoyée est la somme de toutes les valeurs mesurées dans le passé. Le suréchantillonnage et la moyenne sont appliqués avant l’accumulation.

// Sets the initial value of the accumulator to 0
// This is the "starting point" from which the value will change over time
analog.setAccumulatorInitialValue(0);

// Sets the "center" of the accumulator to 0.  This value is subtracted from
// all measured values prior to accumulation.
analog.setAccumulatorCenter(0);

// Returns the number of accumulated samples since the accumulator was last started/reset
analog.getAccumulatorCount();

// Returns the value of the accumulator.  Return type is long.
analog.getAccumulatorValue();

// Resets the accumulator to the initial value
analog.resetAccumulator();

// Sets the initial value of the accumulator to 0
// This is the "starting point" from which the value will change over time
analog.SetAccumulatorInitialValue(0);

// Sets the "center" of the accumulator to 0.  This value is subtracted from
// all measured values prior to accumulation.
analog.SetAccumulatorCenter(0);

// Returns the number of accumulated samples since the accumulator was last started/reset
analog.GetAccumulatorCount();

// Returns the value of the accumulator.  Return type is long.
analog.GetAccumulatorValue();

// Resets the accumulator to the initial value
analog.ResetAccumulator();

Obtention du nombre et de la valeur synchronisés

Parfois, il est nécessairement d’obtenir des mesures appariées du comptage et de la valeur. Cela peut être fait en utilisant la méthode getAccumulatorOutput:

// Instantiate an AccumulatorResult object to hold the matched measurements
AccumulatorResult result = new AccumulatorResult();

// Fill the AccumulatorResult with the matched measurements
analog.getAccumulatorOutput(result);

// Read the values from the AccumulatorResult
long count = result.count;
long value = result.value;

// The count and value variables to fill
int_64t count;
int_64t value;

// Fill the count and value variables with the matched measurements
analog.GetAccumulatorOutput(count, value);

Utilisation d’entrées analogiques dans le code

La classe AnalogInput peut être utilisée pour écrire du code afin de lire les données d’une grande variété de capteurs (y compris des potentiomètres, des accéléromètres, des gyroscopes, des ultrasons, etc.) qui renvoient leurs données sous forme de tension analogique. Cependant, si possible, il est préférable d’utiliser les autres classes WPILib existantes qui appelent et utilisent déjà le code de bas-niveau (lecture des tensions analogiques et conversion en unités significatives). Les programmeurs doivent utiliser AnalogInput en « dernier recours », et privilégier les routines de haut-niveau d’abord.

En conséquence, pour des exemples d’utilisation efficace de capteurs analogiques dans du code, les utilisateurs doivent se référer aux autres pages de ce chapitre qui traitent de classes plus spécifiques.