La mesure d'une petite valeur de capacité via l'estimation constante RC nécessite essentiellement une mesure précise du temps. Les puces ATmega ont une minuterie TCNT1 qui peut être programmée pour incrémenter chaque cycle d'horloge, et peut être arrêtée par un comparateur en utilisant le bit ACIC dans Registre ACSR . Faire tourner un compteur à 16 MHz vous donnera une résolution de 62,5 ns, ce qui est suffisant pour les mesures de capacité dans la gamme picofarad. Voici un exemple de code qui utilise cette technique de mesure.

AnalogRead est environ 1000 fois plus lent, vous serez donc limité à la plage nF si vous l'utilisez.

Notez que vous devez calibrer votre système lorsque vous mesurez une si petite capacité. Cela se fait en exécutant une mesure avec vos sondes connectées mais sans le système cible. Vous soustrayerez ensuite cette valeur de capacité (généralement 20-50 pF, selon les sondes que vous utilisez) de vos mesures brutes pour obtenir la capacité de votre système seul.

Pour une capacité aussi petite que pF, la méthode de constante de temps RC donne des résultats sales sur une carte Arduino.

Vous pouvez utiliser les broches Arduino construites en petite capacité (qui est en Pf lui-même) pour créer un circuit "diviseur de capacité" et calculez un peu comme vous le feriez pour la résistance d'un circuit diviseur de tension.

Voir cet excellent article de Nethercott pour référence capacimètre Arduino

Le moyen standard de mesurer une résistance avec un Arduino est de construire un diviseur de tension en le mettant en série avec une résistance connue. J'ai essayé la même approche pour mesurer les capacités, et il s'avère que cela fonctionne bien dans la plage de 100 pF! Le circuit est comme ceci:

  ┌────────────── Sortie numérique Arduino │──┴── connu──┬── cap │ ├── ────────── Entrée analogique Arduino │──┴── inconnu──┬── cap │ GND  

Le seul problème est que vous devez faire le mesure relativement rapide, sinon vous mesureriez le rapport des résistances de fuite. Voici le protocole de mesure:

1. Réglez les deux broches sur OUPUT LOW afin de décharger les deux condensateurs.
2. Retard d'un ou deux cycles CPU pour s'assurer qu'ils sont complètement déchargés.
3. Réglez la broche d'entrée analogique sur INPUT mode: cela le rendra haute impédance et isolera le nœud qui y est connecté.
4. Réglez la sortie numérique sur HIGH : cela chargera les deux condensateurs en série à 5 V.
5. Délai pour un ou deux cycles CPU pour que la tension se stabilise.
6. Prenez une lecture analogique.

Vous pouvez maintenant déduire la capacité de la lecture en utilisant la même formule que vous utiliseriez avec des résistances, uniquement avec des impédances (ou, simplement 1 / C) au lieu de résistances:

  C_unknown = C_ref × (1024 - lecture) ÷ lecture;  

La même formule peut être dérivée en considérant que le nœud connecté à l'entrée analogique, qui comprend une plaque de chaque condensateur, a une charge nette nulle.

Quelques points à noter:

• Vous allez obtenez la meilleure résolution en choisissant la capacité de référence proche de celle que vous souhaitez mesurer.
• Les retards ne sont pas réellement nécessaires: comme les condensateurs se chargent et se déchargent très rapidement, un seul cycle de processeur correspond à environ 24 constantes de temps. / li>
• Si vous deviez mesurer de grandes capacités (plusieurs nanofarads) avec cette configuration, vous voudriez des résistances de protection en série avec le Broches Arduino, mais alors les délais deviennent obligatoires. Dans la plage de 100 pF, je ne m'inquiéterais pas des courants d'appel.
• Si le délai de l'étape 5 est trop long, votre mesure sera affectée par la fuite des capuchons et de la broche d'entrée analogique.
• Vous n'avez pas à vous soucier du capuchon de 14 pF sur l'échantillon et le circuit de maintien: cela affectera légèrement la toute première mesure mais, une fois que ce capuchon est chargé, la mesure suivante ne sera pas affectée aussi longtemps car le plafond inconnu ne change pas beaucoup entre les mesures consécutives. Vous avez besoin de calibrer la capacité parasite de la broche et des sondes.

Chaque capacimètre Arduino repose sur une propriété des circuits de condensateur à résistance (RC) - la constante de temps. La constante de temps d'un circuit RC est définie comme le temps nécessaire à la tension aux bornes du condensateur pour atteindre 63,2% de sa tension lorsqu'elle est complètement chargée. Les condensateurs plus grands prennent plus de temps à se charger et créeront donc des constantes de temps plus importantes. La capacité dans un circuit RC est liée à la constante de temps par l'équation:

TC = R x C

où TC = constante de temps en secondes R = résistance en ohms C = capacité en farads

Réorganiser l'équation à résoudre pour la capacité donne:

C = TC / R

^{simuler ce circuit - Schéma créé à l'aide de CircuitLab}

Exemple: 1 mégohm * 1 microfarad = 1 seconde

Chaque capacimètre a un circuit RC avec des valeurs de résistance connues et une valeur de condensateur inconnue. L’Arduino mesurera la tension au condensateur et enregistrera le temps nécessaire pour atteindre 63,2% de sa tension une fois complètement chargé (la constante de temps). Comme la valeur de résistance est déjà connue, nous pouvons utiliser la formule ci-dessus dans un programme qui calculera la capacité inconnue.

Comme votre capacité est trop petite dans la plage Pico Farad, vous pouvez donc mesurer directement la capacité via votre analogique broche comme ceci ... Vous avez dit que votre condensateur est de nature dynamique, vous devez donc prendre au moins 10 valeurs et la moyenne pour obtenir une valeur précise.

Code pour mesure Capacité faible dans la plage pF

  const int OUT_PIN = A5; const int IN_PIN = A0; const float IN_STRAY_CAP_TO_GND = 24.48; const float IN_CAP_TO_GND = IN_STRAY_CAP_TO_GND; const float IN_CAP_TO_GND = IN_STRAY_CAP_TO_GND; const float R_PULL const int MAX_ADC_VALUE = 1023; void setup () {pinMode (OUT_PIN, OUTPUT); pinMode (IN_PIN, OUTPUT); Serial.begin (9600);} boucle void () {pinMode (IN_PIN, INPUT); digitalWrite (OUT_PIN, HIGH); int val = analogRead (IN_PIN); digitalWrite (OUT_PIN, LOW); si (val < 1000)
{pinMode (IN_PIN, OUTPUT); capacité flottante = (float) val * IN_CAP_TO_GND / (float) (MAX_ADC_VALUE - val); Serial.print (F ("Capacitance Value =")); Serial.print (capacité, 3); Serial.print (F ("pF (")); Serial.print (val); Serial.println (F (")")); } else {pinMode (IN_PIN, OUTPUT); retard (1); pinMode (OUT_PIN, INPUT_PULLUP); non signé long u1 = micros (); non signé t long; int digVal; faire {digVal = digitalRead (OUT_PIN); non signé long u2 = micros (); t = u2 > u1? u2 - u1: u1 - u2; } while ((digVal < 1) && (t < 400000L)); pinMode (OUT_PIN, INPUT); val = analogRead (OUT_PIN); DigitalWrite (IN_PIN, HIGH); int déchargeTime = (int) (t / 1000L) * 5; délai (déchargeTime); pinMode (OUT_PIN, OUTPUT); digitalWrite (OUT_PIN, LOW); digitalWrite (IN_PIN, LOW); capacité flottante = - (float) t / R_PULLUP / log (1.0 - (float) val / (float) MAX_ADC_VALUE); Serial.print (F ("Capacitance Value =")); if (capacitance > 1000.0) {Serial.print (capacitance / 1000.0, 2); Serial.print (F ("uF")); } else {Serial.print (capacité, 2); Serial.print (F ("nF")); } Serial.print (F ("(")); Serial.print (digVal == 1? F ("Normal"): F ("HighVal")); Serial.print (F (", t =")) ; Serial.print (t); Serial.print (F ("us, ADC =")); Serial.print (val); Serial.println (F (")")); } while (millis ()% 1000! = 0); }  

(fluctue de 50pF à 100 pF).

quelques façons pour de si petites valeurs -> en supposant que vous pouvez vraiment le lire comme un condensateur.

1) forment un réservoir lc et mesurent sa fréquence -> plus efficace pour mesurer la capacité de petite valeur. mais nécessite un inducteur / étalonnage de précision, et est sujet aux parasites.

2) charge / décharge via un CCS: et mesure le temps. le plus simple comme un ccs peut être formé via une grande résistance. pas efficace avec une très petite capacité;

3) transfert de charge: en utilisant la capacité de l'adc. très efficace contre les petites capacités: < 10x de capacité adc. nécessite un étalonnage.

chacun a ses propres problèmes.

La capacité à mesurer étant bien inférieure à 1 nF (50-100 pF), vous rencontrerez de sérieux problèmes en essayant de la mesurer avec l'ADC de l'Arduino en raison de sa capacité d'entrée (14 pF selon la fiche technique). Ajoutez les capacités parasites des fils, des en-têtes et de la carte Arduino elle-même et vous vous retrouverez facilement avec une capacité d'entrée de 25 pF, qui est du même ordre de grandeur que ce que vous essayez de mesurer (= UNE TRÈS MAUVAISE CHOSE).

Que faire alors? Eh bien, les principales options sont les suivantes ...

Utiliser un circuit de mesure externe

Cela signifierait inclure des appareils actifs (amplis op, comparateur, minuteries ...) et des composants passifs de précision . Une vraie solution HW.

La précision de la mesure dans ce cas dépendrait entièrement de la conception (topologie du circuit et sélection des composants) du circuit externe. Le circuit fournirait soit une tension analogique, soit un signal dont la fréquence pourrait être mesurée par l'Arduino sans introduire d'erreurs significatives supplémentaires.

Un exemple utilisant une minuterie 555 (un condensateur de compensation supplémentaire de 4 pF est nécessaire entre OUT et TH pour une précision améliorée):

Source: Utiliser des techniques analogiques pour mesurer la capacité des capteurs capacitifs, un article de Martin Tomasz publié dans Electronic Design.

Considérez le circuit externe comme un "capteur "ou comme circuit de conditionnement de signal pour un" capteur "(la capacité à mesurer). En fait, la capacité dynamique que vous essayez de mesurer provient probablement d'un capteur (humidité, humidité?), N'est-ce pas?

Connectez le condensateur directement aux broches analogiques de Uno et calibrez les lectures

Cela peut sembler incroyable, mais quelque chose d'aussi simple que cela fonctionne (au détriment de la précision, bien sûr):

Comment ça? Parce que le problème de capacité d'entrée que nous avons détecté au début est suffisamment important pour nuire gravement à la précision, mais ne rend pas la mesure complètement irréalisable. Ainsi, nous pouvons étalonner cet effet tout en conservant une mesure valide (bien qu'avec une précision réduite) dans la plage cible (50-100 pF).

L'étalonnage est effectué via certaines valeurs par défaut codées en dur dans ce qui suit Esquisse Arduino (source ici à partir de braulio777). Pour une meilleure précision, vous devez calibrer les valeurs de IN_STRAY_CAP_TO_GND et R_PULLUP dans l'esquisse en comparant les mesures de certains condensateurs avec leurs valeurs de capacité déjà connues (à condition que vous puissiez le faire).

  // Compteur de capacité numérique // Mesure de 0,000pF à 1000uF # include <LiquidCrystal.h>LiquidCrystal lcd (11, 9, 5, 4, 3, 2); const int OUT_PIN = A4; const int IN_PIN = A0; const float IN_STRAY_CAP_TO_GND = 24.48; const float IN_CAP_TO_GND = IN_STRAY_CAP_TO_GND; const float R_PULLUP = 34.8; const int MAX_ADC_VALUE = 1023; void setup () {pinMode (OUT_PIN, OUTPUT); pinMode (IN_PIN, OUTPUT); lcd.begin (16, 2); } boucle void () {pinMode (IN_PIN, INPUT); digitalWrite (OUT_PIN, HIGH); int val = analogRead (IN_PIN); digitalWrite (OUT_PIN, LOW); if (val < 1000) {pinMode (IN_PIN, OUTPUT); capacité flottante = (float) val * IN_CAP_TO_GND / (float) (MAX_ADC_VALUE - val); lcd.setCursor (0,0); lcd.print ("Capacitance ="); lcd.setCursor (0,1); lcd.print (""); lcd.setCursor (0,1); lcd.print (capacitance, 3); // pour la meilleure précision lcd.print ("pF"); } else {pinMode (IN_PIN, OUTPUT); retard (1); pinMode (OUT_PIN, INPUT_PULLUP); non signé long u1 = micros (); non signé t long; int digVal; faire {digVal = digitalRead (OUT_PIN); non signé long u2 = micros (); t = u2 > u1? u2 - u1: u1 - u2; }
while ((digVal < 1) && (t < 400000L)); pinMode (OUT_PIN, INPUT); val = analogRead (OUT_PIN); DigitalWrite (IN_PIN, HIGH); int déchargeTime = (int) (t / 1000L) * 5; délai (déchargeTime); pinMode (OUT_PIN, OUTPUT); digitalWrite (OUT_PIN, LOW); digitalWrite (IN_PIN, LOW); capacité flottante = - (float) t / R_PULLUP / log (1.0 - (float) val / (float) MAX_ADC_VALUE); lcd.setCursor (0,0); lcd.print ("Capacitance ="); if (capacité > 1000.0) {lcd.setCursor (0,1); lcd.print (""); lcd.setCursor (0,1); lcd.print (capacité / 1000,0, 2); lcd.print ("uF"); } else {lcd.setCursor (0,1); lcd.print (""); lcd.setCursor (0,1); lcd.print (capacité, 2); lcd.print ("nF"); } while (millis ()% 1000! = 0);}}  

L'exemple de code ci-dessus affiche les valeurs mesurées sur un écran LCD. Pour votre application, la meilleure option est probablement d'écrire des données sur une carte SD externe.

Divulgation: Je n'ai pas testé moi-même le code ci-dessus.