Come misurare la capacità di un condensatore con Arduino (capacimetro)
Il condensatore è un dispositivo elettrico che può immagazzinare energia sotto forma di cariche elettriche.
La capacità di un condensatore si riferisce alla quantità di carica che può essere immagazzinata tra le sue armature per ogni unità di tensione applicata ai suoi capi.
Dove:
*C capacità del condensatore
*Q la quantità di carica immagazzinata sulle armature
*V è la tensione presente ai suoi capi
La capacità di un condensatore è misurata in farad (F), 1 Farad è 1 Coulomb di carica immagazzinata sulle armature per ogni volt presente ai capi del condensatore.
Il tempo di carica di un condensatore dipende dalla sua capacità e dal valore resistivo attraverso cui viene caricato.
Quando un condensatore è collegato a un circuito attraverso un resistore, per limitare la corrente massima del condensatore, la carica verrà immagazzinata in modo graduale, con legge esponenziale.
Il processo di carica continua fino a quando la tensione ai capi del condensatore non raggiunge quella del generatore.
Il tempo richiesto per raggiungere la tensione massima dipende dalla capacità del condensatore e dal valore di resistenza del circuito, secondo la relazione nota come costante di tempo RC.
La funzione di ricarica del condensatore, tensione in funzione del tempo, ha un andamento di tipo esponenziale come indicato nella figura 2:
Durante la fase di carica, sulle armature del condensatore si accumula carica elettrica:
Se applichiamo una tensione continua ai capi di un circuito RC , nella fase transitoria, cioè nell’istante in cui applichiamo la tensione ai capi del circuito, il condensatore inizia la fase di carica per poi lentamente annullarsi, poiché la tensione ai capi del condensatore raggiunge quella della sorgente.
Se scolleghiamo il condensatore dal circuito e trascuriamo le sue perdite interne, teoricamente il condensatore dovrebbe rimanere carico fino a quando non sarà collegato ad un carico.
Ovviamente, questa considerazione, non è applicabile alla realtà, poichè il condensatore si scaricherà dopo qualche minuto, a causa delle perdite interne al dielettrico che non è un isolante perfetto.
Descrizione del progetto
La relazione matematica che lega la costante di tempo RC all’andamento della tensione di carica del condensatore e data dalla seguente equazione:
*Vc è la tensione ai capi del condensatore
*Vcc è la tensione applicata al circuito
*t la variabile tempo
* RC è la costante di tempo del circuito.
Possiamo rappresentare graficamente l’andamento descritto dall’equazione 1 in Figura 4
Se conosciamo la costante di tempo RC è possibile prevedere l’andamento in funzione del tempo della tensione ai capi del condensatore.
L’obiettivo di questo articolo è di determinare il valore di un condensatore, e per fare ciò, verrà utilizzata l’equazione 1.
Possiamo osservare che dall’equazione 1, trascorso un intervallo di tempo pari a RC, essa diventa:
Ciò significa che dopo RC secondi di carica, la tensione ai capi del condensatore raggiunge il valore del 63,2% della tensione di alimentazione (Vcc).
La strategia che useremo per calcolare il valore della capacità nel circuito di misura RC, è la seguente:
- Tramite un GPIO di Arduino, applichiamo una tensione di 5V al circuito
- Subito dopo, misuriamo il tempo trascorso fino a quando la tensione ai capi del condensatore non raggiunge il valore di 3.15V (63% di 5V)
- Il valore del resistore nel circuito RC è noto e τ l’abbiamo misurato, quindi da questa relazione
Los chema elettrico per realizzazione del progetto è:
Codice
In questo codice, il pin di carica del condensatore viene impostato su valore ALTO per poi subito iniziare la temporizzazione e la misurazione del tempo trascorso durante la carica del condensatore.
Nel processo di misurazione della capacità di un condensatore, il valore di tensione letto ai capi del condensatore, tramite l’ADC, è costantemente monitorato.
Quando tale valore raggiunge il livello di 648 (che corrisponde ad un valore analogico di circa 3,15 V) , la temporizzazione sarà interrotta e la capacità del condensatore verrà calcolata.
Dopo la fase di misurazione della capacità del condensatore è necessario scaricarlo prima di poter effettuare una nuova misura.
Per fare ciò, entrambi i pin di carica e scarica vengono impostati su LOW. Questo permette al condensatore di scaricarsi attraverso il resistore di scarica.
Inoltre, è importante tenere presente che il valore stimato della capacità del condensatore è soggetto ad un limite inferiore di 10 nF.
Ciò significa che il circuito è in grado di misurare condensatori con una capacità superiore a 10 nF, ma non è in grado di rilevare valori inferiori a questo limite.
Il codice è stato sviluppato a partire da quello disponibile sul sito web ufficiale di Arduino, all’indirizzo qui
Invece di utilizzare la funzione millis per misurare il tempo, che si adatta meglio a valori di capacità più elevati, per condensatori con valori più bassi è necessario utilizzare la funzione micros per ottenere una maggiore precisione temporale.
La funzione micros restituisce il tempo trascorso in microsecondi dall’avvio del microcontrollore.
#include <Adafruit_SSD1306.h> // libreria Adafruit SSD1306
int width = 128; // indichiamo le dimensioni del display oled
int height = 32;
Adafruit_SSD1306 oled(width, height, &Wire, -1);
int capPin = A0; // lettura del livellio di tensione ai capi del condensatore
int chargePin = A2; //10kΩ Resistore ri ricarica
int dischargePin = A1; // 220Ω scarica del condensatore
float resistor = 10000.0; // 10kΩ charge resistor
unsigned long startTime;
float mF, uF, nF; //
void setup()
{ // Impstazione OLED
oled.begin(SSD1306_SWITCH CAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextColor(WHITE);
oled.setTextSize(2);
oled.display();
pinMode(chargePin, OUTPUT); // as OUTPUT and to 0V
}
void loop()
{
oled.clearDisplay();
led.setCursor(0,0);
digitalWrite(chargePin, HIGH);
startTime = millis(); // inzio misura del tempo
while(analogRead(capPin) < 648) {} // rimango in questo ciclo fino a quando il valore dell'ADC < 648
mF = (millis() - startTime) / resistor;
// calcolo della capacità = time/R
uF = 1000.0 * mF; //
if (uF > 1)
{
if (uF < 10) oled.print(uF, 1);
else oled.print(uF, 0);
oled.print(" uF");
}
else
{
nF = 1000.0 * uF;
if (nF > 10)
{
led.print(nF, 0);
oled.print(" nF");
}
}
digitalWrite(chargePin, LOW); // set a 0 il pin di ricarica
pinMode(dischargePin, OUTPUT); // inizio a scaricare il condensatore
digitalWrite(dischargePin, LOW); // pongo il livello a 0
while(analogRead(capPin) > 10) {} // rimango in questo loop fino a quando la capacità non si scarica
// discharges
pinMode(dischargePin, INPUT); // blocco la scarica
oled.display();
delay(2000); //
}
#include <Adafruit_SSD1306.h>
Questa riga di codice include la libreria “Adafruit_SSD1306.h”, che è una libreria per il display OLED SSD1306 prodotto da Adafruit. La libreria fornisce una serie di funzioni che semplificano l’utilizzo del display OLED, come ad esempio la scrittura di testo, la visualizzazione di immagini e la gestione della luminosità del display.
int width = 128; int height = 32;
Queste due righe di codice definiscono le dimensioni del display OLED. In particolare, “width” indica la larghezza del display in pixel, mentre “height” indica l’altezza del display in pixel.
Nel codice sorgente, queste variabili sono utilizzate per configurare il display OLED.
Adafruit_SSD1306 oled(width, height, &Wire, -1);
Questa riga di codice crea un oggetto “oled” della classe “Adafruit_SSD1306”, che rappresenta il display OLED collegato ad Arduino.
Il costruttore della classe “Adafruit_SSD1306” richiede quattro parametri: “width” e “height” che indicano le dimensioni del display, “&Wire” che indica l’interfaccia I2C utilizzata per comunicare con il display e “-1” che indica il pin di reset del display (se necessario).
Quindi, il codice crea un oggetto “oled” con le dimensioni specificate (128×32 pixel), utilizzando l’interfaccia I2C “Wire” e non specificando un pin di reset per il display.
oled.begin(SSD1306_SWITCH CAPVCC, 0x3C);
“begin()” è una funzione della classe “Adafruit_SSD1306” che inizializza il display OLED e lo configura con i parametri specificati.
Il primo parametro della funzione “begin()” indica il tipo di alimentazione del display (“SSD1306_SWITCH_CAPVCC” specifica la tensione di alimentazione.
Il secondo parametro imposta l’indirizzo I2C del display OLED (0x3C in questo caso).
startTime = millis();
Nella variabile “startTime” memorizziamo il valore restituito dalla funzione “millis()”, che corrisponde al tempo in millisecondi trascorsi dal momento in cui il microcontrollore è stato acceso.
while(analogRead(capPin) < 648) {}
Il ciclo while controlla il valore letto dal pin “capPin” tramite la funzione “analogRead()”.
In particolare, il ciclo while viene eseguito finché il valore letto dal pin “capPin” è inferiore a 648.
Quando il valore letto dal pin “capPin” supera il valore di soglia di 648, il ciclo while si interrompe e il programma passa alla riga di codice successiva.
mF = (millis() - startTime) / resistor;
Calcoliamo il valore della capacità del condensatore in base al tempo trascorso dal momento in cui il condensatore è stato caricato attraverso il resistore collegata al pin “chargePin”.
In particolare, la riga di codice sottrae il valore memorizzato nella variabile “startTime” (che rappresenta il tempo in millisecondi trascorso dal momento in cui il condensatore è stato caricato) dal valore restituito dalla funzione “millis()” e quindi divide il risultato per il valore della resistenza.
Il risultato di questa operazione rappresenta il valore della capacità del condensatore in millifarad (mF). In sintesi, questa riga di codice calcola la capacità del condensatore in base al tempo di caricamento e al valore della resistenza, utilizzando la legge di Ohm e la costante di tempo RC del circuito.
uF = 1000.0 * mF;
Il valore iniziale della capacità viene moltiplicato per 1000.0, in modo da convertire la misura da millifarad (mF) a microfarad (uF).
while(analogRead(capPin) > 10) {}
In pratica, questa riga di codice viene utilizzata per leggere il valore di tensione presente ai capi del condensatore collegato al pin “capPin”, attendendo che la tensione sul condensatore scenda al di sotto di un certo livello che consideriamo scarico.
Quando il valore letto dal pin “capPin” diventa inferiore al valore di soglia di 10, il ciclo while si interrompe e il programma passa alla riga di codice successiva.
A questo punto il nostro dispositivo è pronto per una nuova lettura.
Conclusioni
Questo progetto semplice ma interessante ci permette di comprendere molti dei concetti teorici di base che riguardano il funzionamento di un condensatore.
In caso di dubbi o domande, non esitate a scrivermi nel form qui di seguito.
Buon lavoro!
