Circuiti RC

Liceo C. Lorenzini

Spiegazione e teoria

Cosa sono?

circuito RC

Fino ad ora abbiamo utilizzato circuiti in condizioni stazionarie, ovvero le cui grandezze fondamentali (correnti, d.d.p., carica dei condensatori ) non variano nel tempo. Un circuito RC è un esempio di circuiti non stazionario.
Il circuito RC contiene, oltre a una batteria o generatore di tensione, una o più resistenze e uno o più condensatori. Consideriamo il condensatore inizialmente scarico.
Attraverso l'interruttore S possiamo mettere in contatto il condensatore con la batteria.



fasi di un circuito RC
  • Fase di Carica: mettiamo in contatto l'interruttore S col punto a. La batteria inizia a trasferire carica al condensatore finche la d.d.p deltaV tra i piatti del condensatore non eguaglia la f.e.m. della batteria.
  • Condensatore totalmente carico: a carica completata la corrente cessa: il condensatore carico interrompe il flusso della corrente.
  • Fase di scarica: scarichiamo il condensatore collegando S col punto b: si genera una corrente nella maglia chiysa che dissipa l'energia del condensatore sulla resistenza R.


Processo di carica del condensatore

circuito RC in carica
In ogni istante del processo di carica, come nel caso statico le equazioni della corrente sono date dalle leggi di Kirchoff. La differenza è che in questo caso le grandezze sono variabili nel tempo.
Sia $q(t)$ la carica, $\Delta V_c(t)$ la d.d.p ai piatti del condensatore, e $i(t)$ la corrente nel circuito. Si ha: $$fem = i(t)R + \Delta V_c(t)$$ La carica del condensatore continua fino a quando la $\Delta V_c$ diventa uguale alla $fem$ del circuito.
Riscriviamo la equazione sostituendo $\Delta V_c(t)$ e $i(t)$ con la loro espressione in termini di carica: $$i(t) = \frac{d q(t)}{dt}$$ $$\Delta V_c(t) = \frac{q(t)}{C} $$ $$\frac{dq(t)}{dt}R+\frac{q(t)}{C} = fem \hspace{1cm}(1)$$ Otteniamo un'equazione differenziale del 1° ordine che descrive la variazione di carica ai piatti del condensatore.
$$ \frac{dq}{dt}R+\frac{q}{C} = fem $$ $$ \frac{dq}{dt}+\frac{q}{RC} = \frac{fem}{R} $$ Quindi applico: $$ q(t)= e^{-A(t)}\Big[C_1+\int{\frac{fem}{R}\,e^{A(t)}\,dt}\Big] $$ con: $$ A(t)= \int{\frac{1}{RC}\,dt} = \frac{t}{RC} $$ Risolvo: $$ \int{\frac{fem}{R}e^{A(t)}\,dt} $$ $$ \int{\frac{fem}{R}e^{\,t/RC}\,dt} $$ $$ Cfem\int{\frac{1}{RC}e^{\,t/RC}\,dt} = Cfem\,e^{t/RC}$$ Quindi: $$ q(t) = e^{-t/RC}\Big[C_1+Cfem\,e^{t/RC}\Big] $$ $$ q(t) = C_1e^{-t/RC}+Cfem $$ Conoscendo $ q(0) = 0$ ricavo: $$ C_1e^{0}+Cfem = 0 $$ $$ C_1+Cfem = 0 $$ $$ C_1=-Cfem $$ Quindi: $$ q(t) = Cfem -Cfem\,e^{-t/RC} $$ $$ q(t) = Cfem\Big[1-e^{-t/RC}\Big] $$
Una volta risolta l'equazione definiamo $\tau = RC$ ottenendo : $$ q(t) = C fem[1-e^{-t/\tau}] $$ $\tau$ prende il nome di costante di tempo caratteristica e ha come untià di misura i secondi. $$ \Big[RC\Big] =\Omega F= \frac{V}{A}\frac{C}{V} = \frac{C}{A} = s $$ Quindi l'intensità di corrente corrisponderà a: $$ i(t) = \frac{dq}{dt} = \frac{C fem}{\tau}e^{-t/\tau} $$
carica su tempo
Grafico della carica sui piatti in funzione del tempo $$q(t)=Cfem\Big[1-e^{-t/\tau}\Big] $$ All’istante iniziale ($t=0$) $q=0$; la carica aumenta esponenzialmente col tempo, e dopo un tempo $t >> \tau$ raggiunge il valore di equilibrio $q = Cfem$ ; a questo punto il condensatore è totalmente carico.
corrente su tempo
Grafico della corrente in funzione del tempo $$i(t)=\frac{dq}{dt}=\frac{fem}{R}e^{-t/\tau} $$ All’instante iniziale $i(0)= E /R$; la corrente diminuisce esponenzialmente nel tempo; per $t >> \tau$ il condensatore è totalmente carico e la corrente si annulla.







ddp su tempo
Grafico della d.d.p. tra i piatti in funzione del tempo $$\Delta V_C(t) = \frac{q(t)}{C} = fem\Big[1-e^{-t/\tau}\Big] $$ A $t=0$ il condensatore è scarico e $\Delta V_C = 0$; per $t >> \tau$ il condensatore è totalmente carico e $\Delta V_C = fem$.


Bilancio Energetico

A carica completata, il bilancio energetico impone che l'energia erogata dalla batteria durante la carica $\Delta U_B$ sia uguale all'energia immagazzinata dal condensatore $\Delta U_C$ più quella $\Delta U_R$ dissipata sul resistore $R$
Verifichiamo questo assunto:

L’energia erogata dalla batteria è data dal prodotto della carica circolata nel circuito per la $fem$ della batteria; la carica $q$ circolata nel circuito durante il processo è ovviamente la stessa accumulata sui piatti del condensatore: $$ \Delta U_B = q\,fem = Cfem^2 $$ $$ \Delta U_C = \frac{1}{2}Cfem^2 $$ $$ q = Cfem $$ Dalla legge di Joule calcoliamo l'energia dissipata sul resistore: $$ P = i^2R = \frac{dU_R}{dt}$$ $$ \Delta U_R = \int_0^\infty{i^2(t)R\,dt} = \frac{fem^2}{R}\int_0^\infty{e^{-2/\tau}\,dt} = \frac{fem^2}{R}\frac{\tau}{2} = \frac{1}{2}Cfem^2 $$ $$ \Delta U_B = \Delta U_C + \Delta U_R$$


Scarica Condensatore

circuitiRCscarica.png

Partiamo dal condensatore carico, con carica iniziale $ q_0 = Cfem $

Chiudiamo il circuito in modo che il condensatore scarichi la sua energia sul resistore $R$; ipotizziamo il verso della corrente in figura; la $2°$ legge di Kichoff dá:
$$ (V_b-V_c)+(V_c-V_b) = 0 $$ $$ iR+ \Delta V_C = 0 $$ $$ \frac{dq(t)}{dt}R + \frac{q(t)}{C} = 0 $$
Si dimostra che la soluzione dell’equazione differenziale è:
$$q(t) = q_0 e^{-t/\tau} $$ $$ i(t) = \frac{dq}{dt} = - \frac{q_0}{\tau} e^{-t/\tau} $$

Verifica sperimentale con arduino

È possibile verificare sperimentalmente ciò che abbiamo imparato nella sezione teoria utilizzando un microcontrollore e assemblando un circuito RC.
Necessario:

Raccolta dati con Arduino

Utilizziamo il nostro arduino per costruire un circuito RC che somigli a questo. Io utilizzerò un resistore da $ 1\cdot 10^{-6} \Omega$ e un condensatore con capacità $ 1 \cdot 10^6 F $
A questo punto non ci resta che scaricare l'IDE di Arduino, scrivere il codice, collegare il microcontrollore al computer ed eseguire il programma.
Ecco un esempio di codice arduino per raccogliere dati:
                int tau;
int R;

int experiment_counter;
void setup() {
  // put your setup code here, to run once:
  tau = 1; // tau = 1 second
  R = 1e6; // R = 1e6 ohm
  experiment_counter = 0;
  int bps = 9600; // velocità, espressa in bps (boud rate per secondo).
  Serial.begin(bps);
  pinMode(2,OUTPUT); // set pin mode of second pin to OUTPUT

  //make sure there is no tension in the capacitor at the beginning of experiment
  digitalWrite(2, LOW); // turn OFF battery
  delay(6*1000); // wait 6 seconds

}

void charge(){
  digitalWrite(2, HIGH); //// turn ON battery
  Serial.print("Experiment n. ");
  Serial.print(experiment_counter);
  Serial.print("\n");
  unsigned long startChargingTime = millis();
  unsigned long chargeTime = startChargingTime;
  int seconds = 6;
  while(chargeTime < startChargingTime+seconds*1000){
     int sensorValue = analogRead(A0); //read tension
     float voltage = sensorValue * (5.0 / 1023.0); // Convert the analog reading (which goes from 0 – 1023) to a voltage (0 – 5V)
     chargeTime = millis(); //get current time
     Serial.print(chargeTime-startChargingTime); // print charging time
     Serial.print(" ");
     Serial.print(voltage); //print voltage
     Serial.print("\n");
     delay(100); //wait 100ms
  }

}

void discharge(){
  digitalWrite(2, LOW); // turn OFF battery
  int seconds = 6;
  Serial.println("Discharging...");
  unsigned long startDischargingTime = millis();
  unsigned long dischargeTime = startDischargingTime;
  while(dischargeTime < startDischargingTime+seconds*1000){
    int sensorValue = analogRead(A0); //read tension
    float voltage = sensorValue * (5.0 / 1023.0); // Convert the analog reading (which goes from 0 – 1023) to a voltage (0 – 5V)
    dischargeTime = millis();
    Serial.print(dischargeTime-startDischargingTime); // print charging time
     Serial.print(" ");
     Serial.print(voltage); //print voltage
     Serial.print("\n");
     delay(100); //wait 100ms
  }

}

void stop(){
  Serial.println("Stopping sketch");
  while(1);
}

void loop() {
  // put your main code here, to run repeatedly:
  charge();
  discharge();
  experiment_counter++;
  if(experiment_counter==50){
    stop();
  }
}
                
              

Analisi dati con Root

Cosa è root?

ROOT è un framework per l'elaborazione dati, nato al CERN, al centro della ricerca sulla fisica delle alte energie. Ogni giorno, migliaia di fisici utilizzano applicazioni ROOT per analizzare i propri dati o per eseguire simulazioni.

Codice e grafico

Ecco un esempio di codice C++ utilizzando root framework per analizzare i dati precedentemente raccolti e disegnare il relativo grafico.
                #include < iostream >
#include < fstream >
#include < string >

#define N_DATA 61 // data gathered during charging/discharging
#define N_EXPERIMENTS 50 // numbers of time the experiment wasrepeted

struct CapacitorData // structure containing data to be plotted
{
    Double_t avg_voltages[N_DATA]; // Y axis
    Double_t avg_times[N_DATA]; // X axis
    int experiment_counter = 0;
};

void readData(std::ifstream &f,CapacitorData &c){
    Double_t time, voltage;
    std::string line;
    for(int i=0;i< N_DATA; i++){
        std::getline(f, line);
        std::istringstream iss(line);
        iss >> time >> voltage;
        c.avg_times[i] = ((c.avg_times[i]*c.experiment_counter) + time/1000)/(c.experiment_counter+1);
        c.avg_voltages[i] = ((c.avg_voltages[i]*c.experiment_counter)+ voltage)/(c.experiment_counter+1);
    }
    c.experiment_counter++;
}
void readFile(string fileName, CapacitorData &c, CapacitorData &d){    
    std::ifstream dataFile;
    string line;
    dataFile.open(fileName);
    if(!dataFile){
        std::cerr<< "Unable to open file: "<< fileName << std::endl;
        exit(1);    
    }
    for(int i=0;i < 2; i++){
        std::getline(dataFile, line); // read "Experiment n. #"
        readData(dataFile, c);
        std::getline(dataFile, line); // read "Discharging..."
        readData(dataFile, d);    
    }   
}

void analysis() {
    CapacitorData charging;
    CapacitorData discharging;
    readFile("capacitor_data.txt", charging, discharging); // read data and fill charging/discharging structures
    TCanvas *c = new TCanvas("c", "Capacitor D.D.P. over time", 200, 200, 950,700); // create canvas
    TGraph *graphFromData = new TGraph(N_DATA,charging.avg_times,charging.avg_voltages);
    graphFromData->Draw();  // draw graph of charging
    TF1 *expectedGraph = new TF1("expectedGraph","5*(1-e^(-x/1))",0,6);
    expectedGraph->Draw("same"); //draw expected graph
    TLegend *legend = new TLegend(.1,.7,.3,.9);     //adding legend
    legend->AddEntry(graphFromData,"d.d.p over time","l");
    legend->AddEntry(expectedGraph,"Expected result","l");
    legend->Draw();
    graphFromData->GetYaxis()->SetTitle("D.D.P. [V]"); // set axis name
    graphFromData->GetXaxis()->SetTitle("Time [s]"); // set axis name}
}
                
              
rootgraph

Analisi dati con python

Possiamo scrivere lo stesso codice utilizzando un altro linguaggio di programmazione: Python. Ci serviremo di uno dei moduli più famosi di python per disegnare grafici, matplotlib. Vediamo il codice:

                  #!/usr/bin/env python
import matplotlib.pyplot as plt
import numpy as np
import math 

#usefull data
N_DATA = 61
N_EXPERIMENTS = 50

def readData(f,d):
    # function that read data and calculate the mean value at same time
    for data in range(N_DATA):
        lineData = [ float(_) for _ in f.readline().split() ]
        d['avg_time'][data] = ((d['avg_time'][data]*d['counter'])+lineData[0]/1000) / (d['counter']+1)
        d['avg_voltages'][data] = ((d['avg_voltages'][data]*d['counter'])+lineData[1]) / (d['counter']+1)
    d['counter']+=1    

def readFile(filename,cd,dd):
    with open(filename,'r') as file:
        for experiment in range(N_EXPERIMENTS):
            file.readline() # read "Experiment n.#"
            readData(file, cd) # read charging data
            file.readline() # read "discharging..."
            readData(file, dd) # read discharging data

def ddp(t):
    #mathematical function 
    fem = 5
    C = 1e-6
    R = 1e6
    return fem*(1-pow(math.e,-t/(C*R)))
    
def plot(data):
    fig = plt.figure()
    t = np.linspace(0.,6.,61)
    plt.plot(t,ddp(t), label="Expected result", color="orange")
    plt.ylabel('D.D.P [V]')
    plt.xlabel('Time [s]')
    fig.suptitle('D.D.P. condensatore su tempo')
    plt.scatter(data['avg_time'], data['avg_voltages'], label='Dati raccolti', marker = '.')
    plt.legend(loc = 'upper left')
    plt.show()

def main():
    #definition of data structure
    chargingData = {'avg_voltages': [0]*N_DATA, 'avg_time': [0]*N_DATA, 'counter': 0 }
    dischargingData = {'avg_voltages': [0]*N_DATA, 'avg_time': [0]*N_DATA, 'counter': 0 }
    readFile("capacitor_data.txt",chargingData, dischargingData) #read data
    plot(chargingData) #plot things
    
# main function implementation 
if __name__ == '__main__':
    main()
                
              

pythongraph

Esercizi

Consideriamo un circuito RC costituito da un condensatore $ C = 5 \mu F $, ed una resistenza di $ R = 10 \Omega $; Il circuito viene vonnesso ad una batteria di $ fem $ uguale a $ 12 V $. Calcolare:

  • La costante di tempo caratteristica $ \tau $ del circuito
  • La corrente nel circuito all'istante di chiusura ($ t=0 $)
  • La d.d.p e la carica ai piatti del condensatore all'istante $ t = \tau /2 $
  • La corrente nel circuito all'istante $ t = \tau / 2 $
  • L'istante in cui la d.d.p ai piatti raggiunge il valore di $ \Delta V = 5 V $