Utiliser votre Arduino pour mesurer la capacité d’un condensateur

arduino condensateur

Aujourd’hui je vais vous faire découvrir une astuce qu’un bon ami m’a enseigné: comment utiliser son Arduino pour mesurer avec précision la capacité d’un condensateur.

Pourquoi mesurer la capacité d’un condensateur alors que c’est écrit dessus ? Tout simplement car si comme moi vous achetez des montagnes de composants en vrac ou en lots, il est fréquent que les inscriptions sur les composants électroniques se soient barrées, ce qui complique alors leur identification et par conséquent leur utilisation.

Grâce à un Arduino seul, vous pourrez alors connaitre et mesurer la capacité de vos condensateurs. Aucun autre composant électronique n’est nécessaire et c’est là tout l’intérêt de cette astuce: rapide et pas chère.

Arduino, mesure de capacités

C’est Jonathan Nethercott qui a donné cette astuce dans son blog: il suffit de brancher le condensateur sur les pins A0 et A2 de votre Arduino, d’utiliser le script suivant et alors vous aurez la mesure de la capacité du condensateur qui s’affichera directement dans votre moniteur série. L’avantage de ce script est qu’il permet de mesurer des capacités allant de 1 pF à plus de 1000 uF!

Le script à télécharger sur votre Arduino est le suivant:

const int OUT_PIN = A2;
const int IN_PIN = A0;
 
//Capacitance between IN_PIN and Ground
//Stray capacitance value will vary from board to board.
//Calibrate this value using known capacitor.
const float IN_STRAY_CAP_TO_GND = 24.48;
const float IN_CAP_TO_GND  = IN_STRAY_CAP_TO_GND;
//Pullup resistance will vary depending on board.
//Calibrate this with known capacitor.
const float R_PULLUP = 34.8;  //in k ohms
const int MAX_ADC_VALUE = 1023;
 
void setup()
{
  pinMode(OUT_PIN, OUTPUT);
  //digitalWrite(OUT_PIN, LOW);  //This is the default state for outputs
  pinMode(IN_PIN, OUTPUT);
  //digitalWrite(IN_PIN, LOW);
 
  Serial.begin(115200);
}
 
void loop()
{
    //Capacitor under test between OUT_PIN and IN_PIN
    //Rising high edge on OUT_PIN
    pinMode(IN_PIN, INPUT);
    digitalWrite(OUT_PIN, HIGH);
    int val = analogRead(IN_PIN);
    digitalWrite(OUT_PIN, LOW);
 
    if (val < 1000)
    {
      //Low value capacitor
      //Clear everything for next measurement
      pinMode(IN_PIN, OUTPUT);
 
      //Calculate and print result
 
      float capacitance = (float)val * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val);
 
      Serial.print(F("Capacitance Value = "));
      Serial.print(capacitance, 3);
      Serial.print(F(" pF ("));
      Serial.print(val);
      Serial.println(F(") "));
    }
    else
    {
      //Big capacitor - so use RC charging method
 
      //discharge the capacitor (from low capacitance test)
      pinMode(IN_PIN, OUTPUT);
      delay(1);
 
      //Start charging the capacitor with the internal pullup
      pinMode(OUT_PIN, INPUT_PULLUP);
      unsigned long u1 = micros();
      unsigned long t;
      int digVal;
 
      //Charge to a fairly arbitrary level mid way between 0 and 5V
      //Best not to use analogRead() here because it's not really quick enough
      do
      {
        digVal = digitalRead(OUT_PIN);
        unsigned long u2 = micros();
        t = u2 > u1 ? u2 - u1 : u1 - u2;
      } while ((digVal < 1) && (t < 400000L));
 
      pinMode(OUT_PIN, INPUT);  //Stop charging
      //Now we can read the level the capacitor has charged up to
      val = analogRead(OUT_PIN);
 
      //Discharge capacitor for next measurement
      digitalWrite(IN_PIN, HIGH);
      int dischargeTime = (int)(t / 1000L) * 5;
      delay(dischargeTime);    //discharge slowly to start with
      pinMode(OUT_PIN, OUTPUT);  //discharge remainder quickly
      digitalWrite(OUT_PIN, LOW);
      digitalWrite(IN_PIN, LOW);
 
      //Calculate and print result
      float capacitance = -(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(capacitance, 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)
      ;    
}

 

Ce script utilise 2 méthodes pour mesurer la capacité d’un condensateur:

  1. la première consiste à mesurer le voltage du condensateur lorsqu’il est connecté en série avec la capacité parasite de l’Arduino. Cette méthode fonctionne pour les petites capacités et elle dépend de la capacité interne de votre Arduino. Cette capacité interne étant spécifique à chaque Arduino, il vous faudra calibrer et modifier dans le script la valeur de la constante IN_STRAY_CAP_TO_GND en utilisant un condensateur de capacité connue.
  2. Pour les condensateurs dont la valeur est supérieure à 1 nF, le script utilisera une autre méthode: charger le condensateur à travers la résistance de tirage (pullup) interne du microcontrôleur ATMega. Là encore il faudra calibrer votre Arduino à l’aide d’un condensateur de valeur connue en modifiant la constante R_PULLUP.

Cette méthode relativement simple fonctionne parfaitement et ne vous coûtera que le prix d’un Arduino. J’en ai un qui est dédié à cette tâche du coup 🙂

14 Responses to Utiliser votre Arduino pour mesurer la capacité d’un condensateur

  1. patrick_83 says:

    bonjour,
    je suis debutant en arduino. Comment faire afficher les resultats sur un ecran lcd 1620 (sheild ou seul) pour rendre l’appareil autonome? J’ai bien rajouté dans le programme #include , LiquidCrystal lcd, lcd.begin, lcd.setCursor(0, 0) et remplacé les serial.print par des lcd.print mais cela ne marche pas. Faut’il obligatoirement passer par un LCD serie ou une interface I2C LCD 1620 ?
    Merci

  2. Nosirus says:

    Bonjour et merci ! j’avais justement besoins de vérifier des condensateurs sans avoir a acheter un appareil en plus xD

    Par contre moi j’ai un mega2560 R3 niveau réglage j’ai pas vraiment compris, ni trouvé ou chercher sur le net, une petite aide ? 🙂

  3. François says:

    La lecture de la valeur des condensateurs n’est pas toujours évidente. Avec ce petit outils tout doute est levé. Il fonctionne très bien. Merci pour cette info. François.

  4. Lainé says:

    Bonjour
    code essayé et cela fonctionne du Feu de Dieu !
    Avec trois fois rien de modifications, juste en changeant le texte de l’anglais au français, il y a là un petit outil bien pratique et particulièrement avec les marquages à la c.., disons les marquages ésotériques.
    J’ai fait des essais avec des capacité de 2 pF, 47pF, 47nF céramiques.
    et 1000 µF électrochimique. Un super outil pour faire du rangement dans les fonds de tiroirs !
    Milles merci, cordialement Jean-Pierre F5NDL

  5. ju says:

    Bonjour tout le monde,

    débutant, je n’arrive pas a faire la manip

    pourriez vous m’éclairer ?

    Je ne comprends pas la démarche , quelle valeur dois je remplacer dans le code ?

    Merci

  6. Ogado says:

    Bonsoir et merci !
    La manip a l’air simple jusqu’au moment du calibrage. Comment procèdes-tu ? « Avec un condensateur de valeur connue », que faut-il saisir comme valeur pour la variable IN_STRAY_CAP_TO_GND ? Celle qu’on lit à l’écran ? Mais où saisit-on également la « valeur connue » du condo ? Il faut bien les deux pour faire le calibre ?
    La question se pose également pour la variable R_PULLUP…

    Merci pour vos réponses.

  7. NorLan says:

    Bonsoir et merci pour ce post très intéressant!
    @Ogado : la procédure de calibration est expliquée (en Anglais) dans le blog de Jonathan Nethercott.
    pour la variable “IN_STRAY_CAP_TO_GND” à http://wordpress.codewrite.co.uk/pic/2014/01/21/cap-meter-with-arduino-uno/ et
    pour la variable “R_PULLUP” à http://wordpress.codewrite.co.uk/pic/2014/01/25/capacitance-meter-mk-ii/ .
    En gros, tu prends une capa, tu la “branches” et tu regardes ce qui est écrit sur le moniteur série. Ensuite tu le reportes dans la formule proposée.

  8. Michel RIAZUELO says:

    Bonjour à tous,

    Je réalise actuellement une application permettant de “lire” une jauge de carburant capacitive (la Capacité de la jauge augmente avec son niveau d’immersion dans le carburant).
    J’utilise aussi un pont capacitif et j’ai besoin de mesurer de mesurer dans quelle plage de valeur la jauge évolue. Je voudrais le faire avec ce programme, mais ….

    Je ne déchiffre pas la ligne de code suivante:
    t = u2 > u1 ? u2 – u1 : u1 – u2;

    Cela doit correspondre à une contraction du code que je ne connais pas …

    Si quelqu’un peut m’éclairer …

    Merci par avance,
    Michel

    PS : je poste pour la é ème fois, j’ai dû mal effectuer la mani la ptemière fois …

Leave a Reply

Your email address will not be published. Required fields are marked *