Curva de carga y descarga de un condensador con Arduino


Bueno, es la primera vez que publico algo sobre electrónica. Lo que vamos a hacer es visualizar la curva de carga y descarga de un condensador con la ayuda de una placa Arduino (en mi caso la Arduino Uno). Si has estudiado algo de electromagnetismo estarás bastante harto de hacer problemas de condensadores que se cargan, que se descargan, que si les metemos un dieléctrico, que si el dieléctrico sólo ocupa un cuarto, etc…

También es práctica obligada de laboratorio el visualizar estas curvas, normalmente con un osciloscopio. El problema de esto que los osciloscopios cuestan alrededor de 1000€, y las placas Arduino entre 15€ y 30€, así que para hacerlo en casa, casi que mejor esto segundo. Evidentemente nuestra placa no es tan precisa como un osciloscopio, pero podremos tener una imagen cualitativa muy buena, e incluso con un poco de cuidado, podremos analizar cuantitativamente los resultados.

Lo que haremos será utilizar la placa para simular una señal de potencial cuadrada (de hecho no la simulamos, la creamos). El circuito es el siguiente:

circ1

Es bastante sencillo. GND es el ground de la placa arduino. 12 es el pin 12 y A0 es el puerto analógico 0 de la placa. La resistencia R1 la iremos variando. El condensador que yo he usado es uno electrolítico de 470\mu F, para manejar tiempos de carga relativamente grandes y que podamos ver en tiempo real la carga/descarga.
Lo que haremos básicamente será poner potencial al pin 12, esperar una cantidad de tiempo, luego quitar el potencial, esperar otra cantidad, volverlo a poner, etc. Así generamos la señal cuadrada.
Ahora calculamos el tiempo de carga del condensador, teóricamente por supuesto, que para eso soy físico (estudiante de física en realidad, peo bue’).
Tenemos que durante la carga, la corriente circulará a través del condensador. Es decir, la carga circulará desde el pin 12 hasta GND pasando por R1 y por C1.
Por definición, la corriente es la cantidad de carga que circula por unidad de tiempo: I=\dot q. Y por la ley de Ohm, la corriente es igual a I=V/R. Siendo V la diferencia de potencial y R la resistencia.
La diferencia de potencial va cambiando en el tiempo, puesto que la pila mantiene una diferencia constante y las placas del condensador aumentan su diferencia de potencial con el tiempo. La diferencia de potencial que nos preocupa, la que promueve el paso de corriente, es la que habrá entre ambos bornes de la resistencia, que será la de la pila menos la del condensador: V=V_0-V_c.
Ahora podemos usar la capacidad del condensador para expresar V_c en función de la carga: C=q/V_c. La C es una constante que define al condensador, de manera que: V=V_0-q/C. Tenemos entonces que:
I=\dot q=\frac{V}{R}=\frac{V_0-q/C}{R}=\frac{V_0}{R}-\frac{q}{RC} .
Tenemos esa ecuación diferencial, que podemos resolver como más nos guste. El resultado es:
q(t)=V_0C\left(1-e^{\frac{-t}{RC}}\right)
Como vemos la carga, y por lo tanto el potencial y la intensidad, son funciones exponenciales que acercarán asintóticamente al valor final sin alcanzarlo. Definimos aquí el tiempo de carga y descarga como \tau =RC, el tiempo en el que el condensador adquiere alrededor de un 67% de su carga.
Siguiendo el montaje de arriba, usaremos el puerto A0 para realizar medidas de voltaje. Al ponerlo en modo INPUT la placa lo pone en un modo de alta impedancia (alta resistencia), podemos entonces considerar que por ahí no pasa corriente, y en conclusión usar el puerto a modo de voltímetro.
Lo primero que haremos será usar una resistencia baja (220 \Omega), cuyo tiempo de carga es de 103 ms. Nosotros intentaremos visualizar la curva más o menos completa, así que esperaremos 500 ms antes de cambiar el estado de la señal.
Para realizar las medidas haremos que la placa mande por Serial la medida del puerto A0 cada milisegundo, nosotros la recogeremos y graficaremos usando Proccessing, que es gratuito: El código de la placa es el siguiente:

void setup() {
  pinMode(12,OUTPUT);
  pinMode(A0,INPUT);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(12,HIGH);
  esperar(100);
  digitalWrite(12,LOW);
  esperar(100);
}

void esperar(int i) {
  for (int j=0;j<i/5;j++) {
    Serial.println(analogRead(A0));
    delay(5);
  }
}

NOTA DE ADVERTENCIA: Antes de cargar el código en la placa, asegúrate de que has montado bien el circuito. Es una muy simple y no tiene mayor peligro, lo único a tener en cuenta es que si usas condensadores electrolíticos, que son muy comunes, y que son los que yo he usado, debes conectarlo bien. Placa positiva al 12 y negativa al GND, así lo tengo yo:

Snapshot_20130519 Snapshot_20130519_1

Comento el código: En la función setup() configuramos los dos pines que usaremos e inicializamos el Serial. En la función loop esperamos 500 ms, cambiamos estado, esperamos otros 500, etc. La función loop, como su nombre indica, se ejecuta constantemente. Como nosotros queremos medir valores mientras la placa espera entre voltaje alto y bajo, en vez de usar la función delay(500), hacemos un bucle y medimos cada 5 ms, que es lo que hace la función esperar(). Si te fijas en el código, medimos cada 5 ms. Podríamos coneguir más resolución midiendo cada 1 ms, sin embargo la función analogRead() tarda cierto tiempo que tiene mucho impacto sobre el milisegundo que esperamos, y las medidas de tiempo quedan falseadas. Puedes probar a medir cada milisegundo, pero entonces esperar(500) hará que pase más tiempo de medio segundo, tendrás que configurar el tiempo un poco a ojo.

Bien, pues si todo está listo cargamos el código. Tal y como tenemos el circuito, lo que estamos viendo es la corriente en función del tiempo. Tenemos que la placa está mandando datos por Serial, así que es hora de recojerlos. En Processing, usaremos el siguiente código:

import processing.serial.*;

 Serial myPort;        // The serial port
 int xPos = 1;         // horizontal position of the graph
 float alt=0;
 void setup () {
 // set the window size:
 size(1200, 300);

 // List all the available serial ports
 println(Serial.list());
 // I know that the first port in the serial list on my mac
 // is always my  Arduino, so I open Serial.list()[0].
 // Open whatever port is the one you're using.
 myPort = new Serial(this, Serial.list()[0], 9600);
 // don't generate a serialEvent() unless you get a newline character:
 myPort.bufferUntil('\n');
 // set inital background:
 background(0);
 }
 void draw () {
 // everything happens in the serialEvent()
 }

 void serialEvent (Serial myPort) {
 // get the ASCII string:
 String inString = myPort.readStringUntil('\n');

 if (inString != null) {
 // trim off any whitespace:
 inString = trim(inString);
 // convert to an int and map to the screen height:
 float inByte = float(inString);
 inByte = map(inByte, 0, 1023, 0, height);

 // draw the line:
 stroke(255,255,255);
 alt = (inByte - height/2)*5;
 point (xPos,height-inByte);//line(xPos, height, xPos, height - inByte);
 //stroke(0,255,0);
 //point (xPos,height-height*0.6321);
 // at the edge of the screen, go back to the beginning:
 if (xPos >= width) {
 xPos = 0;
 background(0);
 }
 else {
 // increment the horizontal position:
 xPos++;
 }
 }
 }

El código está prácticamente calcado del ejemplo “Graph” de la página de Arduino. Bien, si lo ejecutamos, veremos la curva de corriente:

curva1

Si mides con un cronómetro, verás que el tiempo del periodo es un poco mayor del segundo que hemos configurado, pero como sólo queríamos observar la forma cualitativa de la curva, es lo suficientemente preciso. Podemos, a partir de aquí, intentar visualizar el tiempo de carga \tau . Para ello pondremos el potencial bajo, esperaremos lo suficiente como para que la corriente prácticamente se detenga, es decir, que el condensador se descargue completamente, y luego pondremos el potencial alto durante el tiempo de carga de 103 ms. Eso equivale a la siguiente función loop():

void loop() {
  digitalWrite(12,HIGH);
  esperar(103);
  digitalWrite(12,LOW);
  esperar(1000);
}

También descomenta las lineas 40 y 41 del código de Processing:

stroke(0,255,0);
point (xPos,height-height*0.6321);

Lo que hacen es pintar una linea verde en el 63.21% de la altura, que es el punto al que debería llegar la curva en ese tiempo de carga. De nuevo cargamos códigos y ejecutamos el código del Processing para visualizar:
curva2

Como vemos, al esperar el tiempo de carga la curva llega prácticamente a la linea verde. El hecho de que no la toque es un tema de resolución de la placa. Si medimos cada milisegundo en vez de cada 5, como comenté antes, podríamos obtener más resolución, pero falsificaría el tiempo y habría que probar a ojo. Más tarde veremos mejor este efecto, con una resistencia mayor.

Por último en esta configuración, podemos observar lo que pasa si esperamos periodos de tiempo menores al tiempo de carga: la curva debe estabilizarse en torno al centro, y oscilar en torno a ese centro, pero como no tiene tiempo a cargarse ni descargarse del todo, no saldrá de cierto márgen, esperando 40 ms:

curva4

En esta última curva, he tenido que añadir un delay(10000); a la función setup() para que de tiempo a descargarse y pueda verse esa subida.

Ahora podemos probar a visualizar la carga del condensador. Para ello lo único que hay que hacer es cambiar la resistencia y el condensador de sitio:

circ2

En este caso el potencial es directamente proporcional a la carga, así que la curva tendrá la misma forma que la de la carga. Yo obtengo lo siguiente, poniendo la señal de periodo 1 segundo (ambos esperar(500)):

curva3

Aquí se nos presenta un problema. En el tiempo en el que el pin 12 está a potencial 5, la curva empieza a caer, en el siguiente semiperiodo la placa del condensador correspondiente al punto de medida está a potencial negativo (puesto que esa placa tiene carga negativa), y nuestra placa no puede medir potenciales negativos, sólo positivos. Si pudiésemos verlo veríamos que en los semiperiodos en negro, hay una curva simétrica verticalmente a la que vemos. Si quieres puedes hacer que Arduino mida esos potenciales, lo que hay que hacer es poner una serie de resistencias antes del cable que va a A0, y conecta el otro lado a potencial 5V. De esa manera estás moviendo la escala de -5,5V a 0,5V. eligiendo las resistencias adecuadamente, podrás ver esa curva. Yo no lo hecho sobre todo porque considero esa imagen suficiente, y porque ya he visto la curva, pero sobre todo porque al meter ese divisor de potencial, estamos falseando algunas medidas. Sin embargo puede ser interesante intentarlo.

Ahora probemos con una resistencia mayor: 10000 \Omega . Lo que da un tiempo de carga de 4.7 segundos. Esto nos permitirá ver mejor que efectivamente en el tiempo \tau se llega al 60% de carga. Si ponemos en el primer esperar(4700) y en el segundo esperar(30000), obtendremos curvas de carga de un condensador prácticamente descargado. También conviene cambiar la función esperar para que mida cada 100 ms, obtendremos tiempos más precisos y las curvas no quedarán demasiado alargadas (ahora tenemos ciclos de 35 segundos, demasiado largo para visualizarlo con medidas cada 5 ms):

void esperar(int i) {
  for (int j=0;j<i/100;j++) {
    Serial.println(analogRead(A0));
    delay(100);
  }
}

Yo obtengo lo siguiente:

curva5

Como vemos, el primer máximo se pasa un poco porque el condensador empieza con cierta cantidad de carga, y le da tiempo a conseguir un poco más, a partir de ahí, a los 30 segundos el condensador está prácticamente descargado, y los siguiente máximos se quedan justo en la linea verde correpondiente al 63.21%.

Por último, si quieres analizar los resultados con más detalle, puedes hacer lo siguiente: Sin abrir el Processing, pon la placa a funcionar y abre el monitor serial desde el IDE Arduino, ahí verás las lecturas de voltaje, cuando te canses desconecta la placa y copia esos datos al Excel, desde ahí, exporta a un formato de datos estándar, como el .csv, que puede leer cualquier programa de cálculo, por ejemplo Scilab, desde ahí podrás analizar los datos. Ten en cuenta que el tiempo está un poco alargado, puesto que la función analogRead() tarda una cantidad de tiempo apreciable en funcionar (apreciable en grandes cantidades), y que el voltaje está dado en una escala 0-1023, de modo que para pasar a voltios, has de multiplicar por \frac{5}{1023}.

Pues hasta aquí. A ver si me llega el segundo paquete con una segunda breadboard y puedo empezar a hacer cosas que tengo pensadas con la placa Arduino. Ya iré posteando.

Un saludo.

Anuncios
Esta entrada fue publicada en Física, Manuales, Tutoriales y etiquetada , , , , , . Guarda el enlace permanente.

Una respuesta a Curva de carga y descarga de un condensador con Arduino

  1. M. Santamaría dijo:

    Hola!
    Cómo desarrollo esta misma actividad, pero en lugar de utilizar un ´pin digital para caragar y descargar el condensador, utilizo una fuente externa de 10 o 15 V y controlo el proceso de carga y descarga con 2 Relé?

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s