L'article suivant nous a été envoyé par le lecteur Miguel Torres Gordo. Amusez-vous bien à le lire et profitez-en !

Voici le prototype pour mesurer la capacité d'un condensateur avec ATMega328p. Comme la plupart des gens le savent, les broches numériques du microcontrôleur ont une tension de sortie de 5 volts. Nous utiliserons cette tension et la fonction ADC des broches analogiques pour effectuer les calculs nécessaires et déterminer ainsi la capacité des condensateurs.

Tout d'abord, un bref détail sur la charge des condensateurs. Le circuit le plus simple pour charger un condensateur et sa courbe de charge sont :

Si nous connectons un condensateur à une tension, nous pouvons déterminer le temps nécessaire à 63,2% de la tension d'alimentation en utilisant l'équation

T = R * C

où T est la constante de temps en secondes, R est la résistance en ohms du circuit et C est la valeur du condensateur en farads.

Comment pouvez-vous alors déterminer le temps qu'il faut pour charger à 63,2 % ? La réponse est : à l'aide de l'ADC dans les ports analogiques, car 63,2 % de 5 volts sont 3,16 volts. Le circuit simplifié est le suivant :

Le projet dispose d'un commutateur pour sélectionner la mesure des condensateurs dans les plages µF-nF ou nF-pF, ainsi que d'un écran OLED pour afficher les mesures.

Matériaux

• Nano V3.0 avec Atmega328 CH340
• Résistances: 2 x 1 kohm, 1 x 10 kohm, 1 x 220 ohms
• 1 x 0,91 pouces OLED I2C Display 128x32 pixels
• 1 x Interrupteur
• Condensateurs
• Breadboard Kit (ou pin header sockets avec PCB Breadboard set )

Circuit du projet

Circuit de mesure pour les valeurs élevées (F-nF), sélection de la broche D6 avec le commutateur

On commence à charger le condensateur avec la broche A2 à travers la résistance de 10K, en même temps on démarre un timer et on mesure la tension sur la broche A0.  On sait que la tension fournie par les broches est de 5 V. Ainsi, avec l'ADC, on sait que 5 V est égal à la valeur numérique 1023 et que 63,2% de 5 V est égal à 3,16 V, ce qui est égal à 648. Lorsque la lecture de la broche A0 atteint 648, on active l'alimentation et on arrête le timer. Divisez ensuite le temps utilisé par la résistance de 10K pour trouver la valeur du condensateur, puis déchargez le condensateur.

Circuit de mesure pour petites valeurs (nF-pF), sélection de la broche D5 avec le commutateur

Pour les valeurs faibles, on utilise la charge mesurée sur les broches A3 et A0 respectivement. On applique la tension de 5V à la broche A3 via la résistance de 220 ohms et on commence à charger le condensateur. On utilise l'ADC de la broche A0. Si la valeur est inférieure à 976, cela signifie que la valeur du condensateur est dans la gamme des pF. On fait les calculs nécessaires avec la mesure et la plage d'erreur de la résistance interne du Nano V3.0 avec la résistance externe.

Si la valeur sur A0 est supérieure à 976, alors nous réglons la broche A0 pour fournir 5V à la sortie et la broche A3 pour lire la tension. On compte le temps en microsecondes et si dans un temps de 400 ms la tension n'atteint pas 5V, on fait les calculs de la capacité du condensateur avec la valeur de la résistance pull-up interne, la mesure du temps et la valeur de conversion de l'ADC de la mesure de tension en A3. Si le résultat de la valeur est supérieur à 1000, la mesure se fait en µF, s'il est inférieur, elle se fait en pF.

Code source

Voici le code source du sketch pour l'IDE Arduino (Télécharger):

 / * Miguel Torres Gordo - Compacteur Compteur * /
 ​
 // écran d'écran OLED
 #include 
 #include 
 #include 
 #include 
 ​
 #define écran_width 128                            // Écran de largeur OLED
 #define Screen_Height 32                            // écran hauteur moulé
 ​
 // objet de classe adafruit_ssd1306                          
 Adafruit_ssd1306 affichage(Screen_Width, Screen_Height, &Câble, -1);   // -1 Si partager la broche de réinitialisation Arduino
 ​
 // bascule pour sélectionner des valeurs à mesurer
 int Bombepf=5;
 int Scalène=6;
 ​
 // valeurs élevées //
 #define analogpin A0 
 #define charge A2
 #define décharge A1
 #define Resistorvalue 10000.0f                 // Valeur de résistance 10k pour charger le condensateur
 ​
 non signé longue Heure de début;
 non signé longue temps écoulé;
 flotter microfarades;                
 flotter nanofarads;
 ​
 // Basse valeurs //
 const int Out_pin = A3;
 const int In_pin = Août;  
 const flotter In_stray_cap_to_gnd = 50.28;                    // valeur avec 220 résistances 
                                               
 const flotter In_cap_to_gnd  = In_stray_cap_to_gnd;
 const flotter R_pullup = 30.0;  
 const int Max_adc_value = 1023;
 ​
 annuler mettre en place() {
   En série.commencer(9600);
   retard(100);
   En série.imprimeur("Initialiser l'affichage OLED");
 ​
   // Démarrer l'affichage OLED à l'adresse 0x3C
   si (!affichage.commencer(SSD1306_SWITCHCAPVCC, 0x3c)) {
     En série.imprimeur(F("Écran OLED non trouvé"));
     pour(;;); // ne procédez pas, boucle pour toujours
   }
 ​
   punaise(Bombepf, SAISIR);
   punaise(Scalène, SAISIR);
 ​
   punaise(Out_pin, SORTIR);
   punaise(In_pin, SORTIR);
   punaise(épicerie publique, SORTIR);     
 }
 ​
 annuler boucle() {
 ​
   / **************************** Valeurs élevées: Échelle 4F - 100nf **************** ************************** /
 ​
   si (digitalread(Scalène)) {
   
     punaise(Out_pin, SORTIR);
     denadewrite(Out_pin, MEUGLER);                         // a3 comme gnd
     punaise(analogique, SAISIR);                          // A0 Lire la tension
   
     denadewrite(épicerie publique, HAUTE);  
     Heure de début = micros();
 ​
     tandis que (analograde(analogique) < 648) {   }               // le condensateur est chargé
 ​
     temps écoulé = micros() - Heure de début;
     microfarades = ((flotter)temps écoulé / résistorvalue);
      
     si (microfarades > 1) {
 ​
         affichage.cleardisplay();                                     // tampon propre
         affichage.setexteriser(1);                                     // Taille du texte    
         affichage.colstextcolor(Ssd1306_white);                        // texte couleur   
         affichage.setcursor(1, 2);                                    // position du texte
         affichage.imprimeur("Échelle: 4f-100nf");
         affichage.setcursor(1, 12);
         affichage.imprimeur(microfarades);
         affichage.setcursor(50, 12);
         affichage.imprimeur("UF");  
         affichage.affichage();                                          // Afficher le texte à l'écran   
         retard(500);
 ​
     } autre {
 ​
         nanofarads = microfarades * 783;
         affichage.cleardisplay();                                     // tampon propre
         affichage.setexteriser(1);                                     // Taille du texte    
         affichage.colstextcolor(Ssd1306_white);                        // texte couleur   
         affichage.setcursor(1, 2);                                        // position du texte
         affichage.imprimeur("Échelle: 4f-100nf");
         affichage.setcursor(1, 12);
         affichage.imprimeur(nanofarads);
         affichage.setcursor(50, 12);
         affichage.imprimeur("nf");      
         affichage.affichage();                                          // Afficher le texte à l'écran   
         retard(500);
  
     }
   
     denadewrite(épicerie publique, MEUGLER);            
     punaise(déchargement, SORTIR);            
     denadewrite(déchargement, MEUGLER);                        // décharge du condensateur 
   
     tandis que (analograde(analogique) > 0) {   }                 // attend jusqu'à ce que le capacitor soit libéré
 ​
     punaise(déchargement, SAISIR);                           // Cela définit la goupille sur une impédance élevée
   
     affichage.setexteriser(1);                                         // Taille du texte    
     affichage.colstextcolor(Ssd1306_white);                            // texte couleur   
     affichage.setcursor(1, 22);                                       // position du texte
     affichage.imprimeur("Décharge .....");                    // message à afficher   
     affichage.affichage();                                              // Afficher le texte à l'écran   
     retard(1000);
  
   
   }
 ​
   / ***************************** Échelle de faible valeurs 1NF - 1pf **************** ************ /
 ​
   si (digitalread(Bombepf)) {
     
     punaise(épicerie publique, SAISIR);
     punaise(déchargement, SAISIR);                       // Configurez les ports avec une impédance élevée car il n'est pas utilisé
 ​
     punaise(In_pin, SAISIR);
     denadewrite(Out_pin, HAUTE);
     int valourdine = analograde(In_pin);
     denadewrite(Out_pin, MEUGLER);
 ​
     si (valourdine < 976) {
       
       punaise(In_pin, SORTIR);
 ​
       flotter capacitance = ((flotter)valourdine * In_cap_to_gnd / (flotter)(Max_adc_value - valourdine))/2;                        
            
       affichage.ClearDisplay();                                       // tampon propre
       affichage.setexteriser(1);                                       // Taille du texte    
       affichage.colstextcolor(Ssd1306_white);                          // texte couleur   
       affichage.setcursor(1, 2);                                      // position du texte
       affichage.imprimeur("Échelle: 1NF-1PF");                // message à afficher
       affichage.setcursor(1, 12);                     // position du texte
       affichage.imprimeur(capacitance);                 // valeur à afficher
       affichage.setcursor(50, 12);
       affichage.imprimeur("PF");    
       affichage.affichage();                                            // Afficher le texte à l'écran   
       retard(200);
 ​
     } autre {
 ​
       punaise(In_pin, SORTIR);
       retard(1);
       punaise(Out_pin, Input_Pullup);
       non signé longue u1 = micros();
       non signé longue t;
       int digval;
 ​
       faire {
         digval = digitalread(Out_pin);
         non signé longue u2 = micros();
         t = u2 > u1 ? u2 - u1 : u1 - u2;
       } tandis que ((digval < 1) && (t < 400000L));
 ​
       punaise(Out_pin, SAISIR);
       valourdine = analograde(Out_pin);
       denadewrite(In_pin, HAUTE);
       int décharge = (int)(t / 1000l) * 5;
       
       retard(décharge);   
       
       punaise(Out_pin, SORTIR);  
       denadewrite(Out_pin, MEUGLER);
       denadewrite(In_pin, MEUGLER);
 ​
       flotter capacitance = -(flotter)t / R_pullup / Journal(1.0 - (flotter)valourdine / (flotter)Max_adc_value);
       
       si (capacitance > 1000.0) {
         affichage.ClearDisplay();                                         // tampon propre
         affichage.setexteriser(1);                                         // Taille du texte    
         affichage.colstextcolor(Ssd1306_white);                            // texte couleur   
         affichage.setcursor(1, 2);                                        // position du texte
         affichage.imprimeur("Échelle: 1NF-1PF");
         affichage.setcursor(1, 12);
         affichage.imprimeur(capacitance/1000.0, 3);
         affichage.setcursor(50, 12);
         affichage.imprimeur("UF");      
         affichage.affichage();                                              // Afficher le texte à l'écran   
         
         retard(200);    
       
       } autre {
         affichage.ClearDisplay();                                         
         affichage.setexteriser(1);                                             
         affichage.colstextcolor(Ssd1306_white);                                
         affichage.setcursor(1, 2);                                        
         affichage.imprimeur("Échelle: 1NF-1PF");
         affichage.setcursor(1, 12);
         affichage.imprimeur(capacitance, 3);
         affichage.setcursor(50, 12);
         affichage.imprimeur("PF");      
         affichage.affichage();                                                  
         
         retard(200); 
       }
     }         
     tandis que (micros() % 1000 != 0);
   }
 }

Photos du projet

Merci à Miguel Torres Gordo pour cette contribution.