Voltímetro con LCD.
Creado por V. García. En Sept. 2015.
Introducción.
Una vez más asumimos que usted tiene un conocimiento básico adecuado de electrónica, de los circuitos digitales y cómo utilizar un Arduino. Ya que el aprendizaje de la electrónica consiste en un proceso paso a paso, que comprende tanto el trabajo con los circuitos electrónicos como la programación. Vamos a necesitar los siguientes componentes:
 |
 |
 |
|
 |
 |
 |
|
Fig. 1
Una fuente de alimentación que muestre la tensión y la corriente que consume un circuito bajo prueba es sin duda una fuente que nos proporciona unos datos añadidos que hace más fácil nuestro trabajo, lo cual no quiere decir que si no dispone de estos instrumentos no sea una fuente de calidad, en absoluto. Naturalmente que en el caso de disponer de estos elementos de medida, resulta más completa y compensa la diferencia de coste. Así que, este es el motivo de este artículo. Se trata de disponer de una pantalla de bajo costo que no muestre la tensión que esta entregando la fuente de alimentación y además si nos muestra la corriente que consume el circuito, mucho mejor y más completa.
En otro artículo que realicé decía: «Actualmente, gracias a las nuevas tecnologías, tomar una muestra de la tensión en un punto de un circuito, casi no influye en el funcionamiento de éste, ya que la alta impedancia de los circuitos que utilizamos nos hacen fácil este cometido.»
Un voltímetro mide la tensión entre dos puntos de un circuito, y con la electrónica digital actual, podemos realizar un verdadero voltímetro que podemos instalar en nuestra fuente de alimentación. Los voltímetros digitales funcionan mediante la conversión del valor analógico leído, a un valor digital mediante un convertidor analógico a digital (ADC). Nosotros vamos a utilizar un Arduino típico tiene varios de estos convertidores en él, con una precisión que será suficiente para este cometido, en este tutorial veremos cómo leer voltajes de entradas analógicas en Arduino y construir un voltímetro que mide voltajes (DC) en corriente continua.
Por supuesto que lo que nos interesa es medir los parámetros que se generan en la fuente ajustable. Para ser sincero he dudado en qué tipo de pantalla utilizar, ya que una pantalla del tipo Nokia-5110, quedaba pequeña para aplicar en una fuente de alimentación que generalmente está de forma estática en el laboratorio y por lo tanto quizás el tipo Nokia estaría mejor para un voltímetro portátil. Por eso vamos a utilizar una pantalla del tipo LCD de 2 líneas o en mi caso una de 4 líneas como es el LCD2004A que en la actualidad al igual que aquella es muy común.
El esquema.
El esquema es muy sencillo, ya que se reduce a un divisor de tensión básico el cual constituirá en si mismo la impedancia de entrada y cuya salida es la tensión que aplicaremos a un pin analógico. El esquema muestra el divisor ya que el resto no tiene relevancia.
Fig. 2
Del esquema podemos extraer unos conceptos importantes para el caso:
- El divisor de tensión
- Impedancia de entrada
- Protección de entrada
Circuito Divisor Tensión.
Las entradas analógicas de un Arduino pueden medir hasta 5V (cuando se utiliza la tensión de referencia analógica incorporada). Incluso cuando sólo se conecta a un circuito de 5V, debe utilizar las resistencias para ayudar a proteger el Arduino de cortocircuitos o sobrecargas de tensión inesperadas.
Se trata de un sencillo circuito divisor de tensión que consta de dos resistencias (R1 y R2) en serie que, se encargan de dividir el voltaje de entrada, para adaptarlo a la ventana de tensiones que pueden leer las entradas analógicas del Arduino (5V).
El divisor entrega una tensión al pin analógico de Arduino que éste convierte en un formato digital que puede ser procesada por el microcontrolador. En este caso, la tensión entrada después de pasar por el divisor de tensión descrito (R1 y R2), se aplica al pin A0 (usted puede utilizar otro pin).
El circuito con los valores mostrados para R1 de 1MΩ en serie con R2 de 100KΩ representa una impedancia de entrada de 1MΩ + 100kΩ = 1’1M, que reduciendo es = 11, factor de división que es adecuado para la medición de voltajes de DC hasta aproximadamente 55V.
Fig. 3
El circuito mostrado divide el voltaje de entrada conectado al pin análogo Arduino, equivalente a la tensión de entrada dividido por 11, por lo tanto el máximo es de 55V ÷ 11 = 5V, por seguridad daremos un margen y podemos decir que es un voltímetro para un margen de 0-30V DC.
Principios de funcionamiento.
Impedancia de entrada.
Si un voltímetro tiene una baja impedancia de entrada baja, digamos 10kΩ y se está midiendo un voltaje a extremos de una resistencia de 10kΩ, el multímetro está cambiando efectivamente el valor de la resistencia a 5KΩ ( ya que dos resistencias de 10kΩ en paralelo = resistencia 5kΩ). Por consiguiente, el voltímetro ha cambiado los parámetros del circuito, y realmente, está leyendo una tensión errónea. Esas dos resistencias forman un divisor de potencial que se utiliza para bajar el voltaje que se mide a un nivel que Arduino pueda leer, además de ser la impedancia de entrada.
Un conjunto multímetro digital para medir voltaje DC típicamente tendrá una impedancia de entrada de 10MΩ o superior. Esto significa que la resistencia entre las dos sondas o terminales del multímetro es de 10MΩ o más.
Así pues, es deseable una alta impedancia de entrada para un voltímetro (o multímetro en la escala de voltaje). Cuanto mayor impedancia de entrada, menos probable es que el multímetro influya o cambie lo que esta midiendo del circuito. Al medir (con un multímetro que tiene una impedancia de entrada de 10 millones de ohmios) el voltaje a extremos de un componente en un circuito, es el mismo que la conexión de una resistencia de 10MΩ en paralelo con el circuito; no influye.
Así que, queremos una alta impedancia de entrada en nuestro circuito divisor de tensión, y que la impedancia de este «voltímetro» no vaya a influir en el circuito que se esté bajo prueba.
Sin embargo, como regla general, un dispositivo de alta impedancia de entrada será generalmente propenso a recoger más ruido o interferencias (EMI) que un dispositivo de baja impedancia de entrada, por ese motivo se debe adaptar un filtro de paso alto.
La fórmula para calcular los valores en un divisor de tensión es:
|
1 |
Vout = (R2 / (R1 + R2)) * Vin |
Por lo tanto, puesto que Arduino admite un Vmax de 5V en sus entradas analógicas, si el divisor está funcionando correctamente, entonces el Vout será de un máximo de 5V, y para poder calcular la tensión máxima de entrada al circuito usaremos:
|
1 |
Vmax = 5,0 / (R2 / (R1 + R2)) |
Nota: Si utiliza resistencias de valores diferentes de los sugeridos aquí, debe recordar de ajustar los valores de R1 y R2 en el boceto, las resistencias deben ser del 1% de precisión si es posible o mejor. Usted puede ver una variación de esta expresión utilizada en la rutina de setup() del programa.
Voltímetro con Arduino
Utilizando el monitor Serial para mostrar los valores.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
// // Voltimetro_dc.ino // hispavila.com // Construcción de un voltímetro DC con Arduino // 20.09.2015 // Utiliza el monitor Serial para mostrar los valores. // float v1 = 4.98; // valor real de la alimentacion de Arduino, Vcc float r1 = 1000000; // 1M float r2 = 100000; // 100K void setup() { Serial.begin(9600); Serial.println("--------------------"); Serial.println("DC VOLTMETER"); Serial.print("Maximum Voltage: "); Serial.print((int)(v1 / (r2 / (r1 + r2)))); Serial.println("V"); Serial.println("--------------------"); Serial.println(""); delay(2000); } void loop() { float v = (analogRead(0) * v1) / 1024.0; float v2 = v / (r2 / (r1 + r2)); Serial.print("V: "); Serial.println(v2); delay(10); } |
Con todos los cálculos completados, suba el código al Arduino y ya puede ver en el monitor el resultado. El valor v1 ahora representa la tensión real medida por el circuito, que se envía a la pantalla. Debería ver algo parecido a la imagen siguiente.
Fig. 4
Por supuesto que los valores de tensión que muestra, están cambiando de un modo que no se ajusta a lo que desearíamos. Cuando esto ocurre es debido en principio a unos motivos que debemos tener en cuenta: uno es debido al ADC que tiene Arduino por lo que no podemos hacer demasiadas cosas (también existe el factor ±1 dígito), otro motivo son las interferencias, para eso podemos dotar de un condensador cerámico de 10nf a 100nf, y otro motivo que si abordaremos más adelante, es dotar de un filtro de soft que tienda a reducir estos indeseados cambios.
Ideal Fig. 5 Ruido
Con el mencionado condensador reduciremos en parte los picos que se aprecian en la imagen anterior. De momento vamos a tener en cuenta los factores que debemos conocer y podemos abordar.
Precauciones.
Debemos tener en cuenta como alimentamos el Arduino, con baterías o por cable USB, es decir, si lo está por baterías u otra fuente aislada o por una una fuente a red, en cuyo caso, ambos deben compartir las tierras, lo que se llama masa común (GND) o una conexión a 0V con el circuito bajo prueba. Si la conexión de GND del Arduino se conecta a cualquier otra parte del circuito bajo prueba excepto GND, entonces esto es lo mismo que hacer un cortocircuito de ese punto del circuito a GND.
El GND del Arduino es como el cable negativo o común (COM) de un multímetro, algo que se debe considerar para ser conectado permanentemente al GND del circuito bajo prueba por seguridad, a menos que el Arduino o el circuito bajo prueba esté completamente aislado y «flotante».
Protección de entrada.
Los valores de resistencia en el diagrama del circuito anterior proporcionan cierta protección contra sobretensión en la medición de voltajes bajos como 5V, 9V o 12V. Así que, si accidentalmente se mide una tensión de digamos 30V, no va a estallar el pin de entrada analógica de Arduino.
Cualquier tensión superior a aproximadamente 55V puede dañar el Arduino. El punto de la red de resistencias divisoras conectada a la patilla analógica del Arduino es equivalente a la tensión de entrada dividido por 11, por lo que 55V ÷ 11 = 5V. En otras palabras, cuando se miden 55V, el pin analógico de Arduino estará en su máximo voltaje de 5V.
Proporcionar esta protección básica a sobrecarga de tensión es a expensas de no usar el rango completo del ADC de 10-bit de entrada analógica si solamente se van a medir voltajes inferiores, pero todavía se pueden medir los cambios de alrededor de 0.054V. Tener en cuenta que en el circuito, no se muestra ninguna otra protección para los picos de tensión, tensión inversa o voltajes superiores a 55V.
Como se ha mencionado, vamos a procurar un modo de reducir el salto de los valores, por lo que vamos a introducir una suma de valores y sacaremos la media para utilizar este valor como valor de lectura. Este es el programa que usaremos.
Lector de tensión
Lector de tensión, voltímetro versión 2
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
// número de muestras analógicas a tomar para la lectura #define NUM_SAMPLES 20 int sum = 0; // suma de muestras hechas unsigned char sample_count = 0; // numero de la muestra float voltage = 0.0; // voltaje calculado void setup() { Serial.begin(9600); } void loop() { // tomar un número de muestras analógicas y sumarlas while (sample_count < NUM_SAMPLES) { sum += analogRead(A0); sample_count++; delay(10); } // calcular la tensión de utilizar 5,0 para una tensión 5.0V // ADC de referencia // 5.015V es la tensión de referencia calibrada voltage = ((float)sum / (float)NUM_SAMPLES * 5.015) / 1024.0; // Envia voltaje para su visualización en tensión Serial Monitor // multiplicado por 11 cuando se utiliza divisor de tensión que // divide por 11. // 11.132 es el valor calibrado del división de tensión Serial.print(voltage * 11.132); Serial.println (" V"); sample_count = 0; sum = 0; } |
Cómo funciona el Código.
Para medir la tensión en la rutina loop(), utilizamos la función analógica analogRead(0), para leer la entrada analógica A0 en este caso. El valor que nos devuelve, es un entero dentro del rango de 0 a 1023, por dicho motivo lo debemos ajustar en la ventana de 0 a 5V que, es el margen de Arduino. Dicho valor leído lo multiplicamos por el nivel real de alimentación y lo dividimos por 1024. Proporcionamos algún tipo de filtrado sencillo, mediante la suma de 10 valores analógicos del pin A0 muestreado a intervalos de 10 ms.
Para una mayor precisión, se toman diez muestras analógicas usando el siguiente código:
while (sample_count <NUM_SAMPLES) {
suma + = analogRead (A0);
sample_count ++; // incrementa la cuenta
}
El total de los 10 valores sumados, se almacenan en la variable suma. La variable de sample_count sigue la pista del número de muestras. Ambas variables se restablecen después de calcular y mostrar la tensión:
sample_count = 0;
suma = 0;
El número de muestras tomadas puede ser cambiado en la parte superior del boceto, en: #define NUM_SAMPLES 10. Sin embargo, no haga este valor demasiado alto o la suma de dichas muestras será demasiado grande para caber en la variable suma.
La tensión la calculamos de la siguiente forma:
voltaje = ((float) suma / (float) NUM_SAMPLES * 5.01) / 1024,0;
Un valor de calibrado se utiliza en lugar de 5,01 en el boceto de arriba (la calibración se detalla más adelante).
La suma de las 10 muestras se divide por 10 (NUM_SAMPLES) para obtener el valor medio.
Si 5.0 es la tensión de referencia de 5V ADC. El valor 1024.0 es el valor máximo que el ADC puede tener más 1 (1023 + 1 o sea, 2 a la potencia de 10 más 1) también se puede utilizar aquí 1023.0. Esto calcula la tensión dividida, por ejemplo el voltaje en el pin A3.
El voltaje real se calcula multiplicando la tensión leída, por el factor de división de la red del divisor de tensión (parece lioso), mejor con esta expresión:
|
1 |
Serial.print (tensión * 11,0); |
La línea de código anterior calcula la tensión real y luego la envía al puerto serie para mostrar en la ventana del monitor de serie. El boceto utiliza un valor calibrado en lugar de 11,0 como se muestra arriba.
Tengamos en cuenta que por diferentes razones, se produce un error de medición en este medio de 1,5%.
Calibración del circuito y Arduino.
Podríamos obtener un voltaje más preciso mediante el uso de un voltaje de referencia de precisión para el ADC y además el uso de resistencias del 1% de tolerancia o mejores. Lo ideal sería un ADC mayor de 10Bits, si está interesado en el tema, puede visitar este sitio.
Veamos como calibrar la tensión ADC de referencia. Tenemos que medir los 5V del regulador del Arduino (que se encuentra en el pin 5V de Arduino). Este voltaje se utiliza para la tensión de referencia ADC de forma predeterminada en Arduino. Cada Arduino tiene un regulador de tensión es probable que sea ligeramente diferente para cada Arduino, debe ser calibrado de forma individual. Ahora pongamos el valor real medido 4.976V en el boceto de la siguiente manera.
|
1 |
voltaje = ((float) suma / (float) NUM_SAMPLES * 4.976) / 1024,0; |
En el ejemplo anterior, el voltaje medido en el pin de 5V Arduino era 4.976V.
Otra forma de obtener una lectura más precisa es calibrar el circuito. La calibración se puede realizar midiendo el valor real de la tensión de referencia y los valores reales de las resistencias del divisor de tensión. Estos valores pueden entonces ser utilizados en los cálculos en el código del boceto Arduino.
Conecte una fuente de alimentación estable, tal como una batería de 9V a través de la red de resistencias R1 y R2. Mida el voltaje a extremos de las dos resistencias conectadas a la batería, es decir, medir el voltaje de la batería. Ahora, mida el voltaje a extremos del resistor (R2) de 100kΩ es decir, entre el pin A0 (en Arduino) y GND.
El factor divisor de tensión se calcula dividiendo la tensión tomada a extremos de R1÷R2 por la tensión en A0 o sea:
|
1 |
factor de división = tensión de entrada ÷ tensión de salida |
Por ejemplo, si la entrada de voltaje medido es 10.02V y la salida (voltaje en el pin A0) es 0.91V, entonces el factor de división es:
|
1 |
10.02 ÷ 0.91 = 11,011 |
Ahora, usaremos este valor en el código del boceto Arduino:
|
1 |
Serial.print (tensión * 11.011); |
Si se utiliza la calibración, luego se pueden utilizar resistencias de tolerancia 5%, para el divisor de tensión.
Si cuando comparamos las lecturas de la pantalla LCD con las del Voltímetro digital de laboratorio, éstas no coinciden, no nos inquietemos, tomemos el multímetro digital de precisión y comprobemos la alimentación de 5V entre los pines 5V y GND de la placa Arduino. Podría ser que debido al USB, nos de menos (por ejemplo 4.98V), en ese caso, sustituyamos dicho valor del Vout = (valor * 5.0) / 1024.0 en el código del boceto (es decir, sustituir el valor 5.0, al de la lectura Vcc real, en este caso 4.98V). Además, tratemos siempre de usar resistencias de precisión del 1% de tolerancia para las resistencias R1 y R2.
|
1 |
float v1 = 4.98; // valor real de la alimentación de Arduino, y no 5V |
Como ya se ha dicho, los valores de las resistencias (R1 y R2) en el diagrama del circuito, proporcionan cierta protección contra sobretensiones y puede medir voltajes bajos. Tenga en cuenta que cualquier tensión de entrada superior a aproximadamente 55V podría freír el Arduino. Sin incorporar otro tipo de protección en este circuito contra picos de tensión, tensiones inversas o voltajes más altos.
Mejorar el voltímetro.
El voltímetro que se ha presentado aquí es muy básico lo cual da un amplio margen para mejoras, como pueden ser: varias escalas para diferentes alcances, añadir una pantalla LCD que nos informe de los distintos valores de la tensión que está entregando en un momento dado, otra posibilidad es realizar el mismo proyecto en una pastilla más pequeña en lugar de usar el típico Arduino.
Como se ha dicho son varias las posibilidades de mejora, de modo que aquí sólo veremos alguna de esas opciones. Este es un ejemplo del código que vamos a probar.
Voltímetro DC.
Código de ejemplo para visualizar el voltaje, versión 3.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
// // Voltimetro_dc.ino // hispavila.com // Construcción de un voltímetro Arduino DC // 20.09.2015 // // include the library code: #include "LiquidCrystal.h" //Fire up the library LiquidCrystal.h // inicializamos la librería con los de pines de la interface //LCD: (RS, E,D4,D5,D6,D7) LiquidCrystal lcd(8, 7, 6, 5, 4, 3); // #define NUMREADINGS 20 //10 los valores para leer int readings[NUMREADINGS]; //Las lecturas de la entrada analógica int index = 0; //Indice de la lectura actual int total = 0; // lectura Total int average = 0; //Media float vcc = 4.98; // valor real de la alimentacion de Arduino, Vcc float r1 = 1000000; // 1M float r2 = 100000; // 100K void setup() { Serial.begin(9600); { for (int i = 0; i < NUMREADINGS; i++) readings[i] = 0; //Pone toda la matriz a 0 } lcd.begin(20, 4); Serial.println("--------------------"); Serial.println("VOLTMETRO DC"); Serial.print("Voltaje Maximo: "); Serial.print((int)(vcc / (r2 / (r1 + r2)))); Serial.println("V"); Serial.println("--------------------"); Serial.println(""); lcd.setCursor(2, 0); // lcd.print("Voltimetro DC"); lcd.setCursor(0,1); lcd.print("09-2015 - Hispavila"); lcd.setCursor(0,2); lcd.print("Voltmetro.ino"); delay(2500); lcd.clear(); } void loop() { total -= readings[index]; //Resta la última lectura readings[index] = analogRead(0); //Lee los valores de A0 y guarda en la matriz total += readings[index]; //Añade la lectura a total index ++; //Incrementa el índice if (index >= NUMREADINGS) index = 0; //Al final de la matriz se restablecerá el índice a 0 average = total / NUMREADINGS; //Calcula la media if (index < =20) // para que no muestre los primeras lecturas return(loop()); float v1 = (average * vcc) / 1024.0; float v2 = v1 / (r2 / (r1 + r2)); lcd.setCursor(0,0); lcd.print("Voltimetro "); lcd.print((int)(vcc / (r2 / (r1 + r2)))); lcd.print("V max."); lcd.setCursor(0,2); //Col 0, fila 2 lcd.print("Voltios: "); lcd.print(v2); lcd.print(" V"); Serial.print("V: "); Serial.println(v2); delay(1500); } |
Con este ejemplo se ha mejorado algunas cosas, como se describe en el propio listado. Un paso importante es haber puesto a 0 la matriz readings[i], esto es una buena práctica ya que asegura la igualdad de valores. Otro punto es que dentro del loop(), como indica el comentario, se ha reducido una lectura total -= readings[index]; la última del bucle. Y por último, se ha realizado un bucle de 20 pasos para reducir los molestos incrementos de las cuentas hasta que se estabilizan.
En el párrafo anterior se han descrito unas mejoras que han servido para dar un aspecto más acabado a nuestro voltímetro. En los comentarios se da una idea del porque de cada rutina.
Fig. 6
Anexo 1.
Debido a las consultas recibidas para mejorar el código que se muestra más arriba, he tenido que revisar con atención y realizar un nuevo código que satisfaga las necesidades de los que se han decidido a construir un voltímetro con un LCD, así que sin más preámbulos, presento el código.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
/* Un circuito útil para los amantes y los experimentadores Arduino. Es un simple voltímetro digital, que puede medir con los valores de las R1 y R2 con seguridad voltajes de corriente continua de entrada en el rango de 0 a 55V, aunque para más seguridad sería conveniente no rebasar los 30V. funciona bien 05.08.2016 */ #include <LiquidCrystal.h> // lib. LiquidCrystal.h // LCD:..........RS,E,D4,D5,D6,D7) LiquidCrystal lcd(8,7, 6, 5, 4, 3); // int analogInput = A0; float vout = 0.0; float vin = 0.0; float R1 = 100000; // resistance of R1 -see text! float R2 = 10000; // resistance of R2 -see text! int value, val = 0; void setup(){ Serial.begin (9600); Serial.println("DCVoltmeter"); Serial.println("DCVoltmeter2.ino"); Serial.println("05.08.2016"); pinMode(analogInput, INPUT); lcd.begin(20, 4); lcd.setCursor(0,0); lcd.print("DC VOLTMETER"); lcd.setCursor(0,1); lcd.println("DCVoltmeter3.ino"); lcd.setCursor(0,2); lcd.println("30.08.2016"); delay(1500); lcd.clear(); } void loop(){ float sampleBVal = 0; // read the value at analog input for (int x = 0; x < 500; x++){ val = analogRead(analogInput); sampleBVal = sampleBVal + val; } float value = sampleBVal/500; float vout = ((value * 5.0)+ 12) / 1024.0; // see text // el +12 es un valor ajustado para compensar los valores restantes float vin = vout / (R2/(R1+R2)); Serial.print("Volts= "); Serial.println(vin); lcd.setCursor(0,0); lcd.print("DC VOLTMETER"); lcd.setCursor(0, 1); lcd.print("OUTPUT V= "); lcd.setCursor(10, 1); lcd.print(vin, 2); lcd.print(" "); delay(500); } |
Si usted decide realizar este montaje tendrá la satisfacción de conseguir un voltímetro con muy buenas prestaciones.
Otras posibilidades.
Aunque no vamos a realizar un voltímetro para corriente alterna, si quiero dar una orientación para los que estén interesados en el tema. Para medir AC, en un voltímetro sin grandes pretensiones, como el estudiado más arriba, yo elegiría insertar un diodo entre la unión de las dos resistencias (ánodo) y el cátodo a la entrada de Arduino, con un condensador de bajo valor entre la entrada analógica y tierra, como se aprecia en la imagen que sigue:
Fig. 7
Suponiendo que la impedancia de entrada es razonablemente alta, incluso un pequeño condensador de 10nF, permitiría que el pico de voltaje AC a través del condensador pueda alcanzar la tierra. Utilice los cálculos originales R1 / R2 para el rango de tensión apropiado, pero no se olvide de la caída de tensión directa (0.65V) a través del diodo. A ser posible, utilice un diodo Shottky para reducir esta a 0.3V, si está tratando bajos voltajes.
Estoy preparando un nuevo artículo como ampliación del tema. Esto es todo por este momento, espero poder presentar una nuevo artículo más completo pronto.
Ayúdenos a mantener la comunidad en lo positivo y útil.
Sobre el tema, sea respetuoso con todas las edades y niveles
con la habitual responsabilidad.
Sea amable y no haga Spam – ¡Gracias!.
Very nice article:-). Best regards to author
Thank you Ann
Hola buen día, estoy tratando de hacer un circuito que haga el monitoreo de la red eléctrica (110/200) y ver los cambios en los niveles de voltaje ya sea utilizando arduino o un FPGA, ¿este circuito funcionaría?
Hola Fernando Ruiz.
El circuito básicamente te sirve, en cualquier caso debes poner atención en el divisor de tensión ya que debes realizar los cálculos para la tensión máxima o algo más en el caso de la tensión de red, yo lo haría sobre los 240V.
Por otra parte tienes que tener en cuenta que vas a medir tensiones alternas y el microprocesador directamente no admite tensiones alternas, con lo que, tendrás que rectificar y filtrar dichas tensiones, también debes filtrar el ruido eléctrico de la red.
Quizás deberías utilizar la tensión alterna procedente del divisor, rectificandola y reduciéndola ya que al rectificar y filtrar aumenta por 1.4142 (√2).
En definitiva, si puedes hacerlo.
Saludos
hola amigo buenas tardes.
// número de muestras analógicas a tomar para la lectura
#define NUM_SAMPLES 20
int sum = 0; // suma de muestras hechas
unsigned char sample_count = 0; // numero de la muestra
float voltage = 0.0; // voltaje calculado
void setup()
{
Serial.begin(9600);
}
void loop()
{
// tomar un número de muestras analógicas y sumarlas
while (sample_count < NUM_SAMPLES) {
sum += analogRead(A0);
sample_count++;
delay(10);
}
// calcular la tensión de utilizar 5,0 para una tensión 5.0V
// ADC de referencia
// 5.015V es la tensión de referencia calibrada
voltage = ((float)sum / (float)NUM_SAMPLES * 5.015) / 1024.0;
// Envia voltaje para su visualización en tensión Serial Monitor
// multiplicado por 11 cuando se utiliza divisor de tensión que
// divide por 11.
// 11.132 es el valor calibrado del división de tensión
Serial.print(voltage * 11.132);
Serial.println (" V");
sample_count = 0;
sum = 0;
}
este codigo que pusiste solo me arroja 0.9 ,0.8 de una pila de 9v
Hola Pedro Cacho
Es posible que tengas razón. Las resistencias del divisor tiene mucho que ver con los valores leídos y por otra parte el código se puede mejorar, piensa que es un boceto orientativo. Estoy trazando un nuevo código y tal vez en un par de días lo pueda subir.
Siento que los valores obtenidos no estén dentro de lo esperado. Trata de mejorar el código, sería interesante ya que te ayudaría a comprender mejor el programa.
Saludos.
I have recently started a web site, the info you provide on this site has helped me greatly. Thank you for all of your time & work. There can be no real freedom without the freedom to fail. by Erich Fromm.
Hola Dani.
Ese componente es el propio regulador.
Saludos.
Buenas Amigo hispavila muy buen proyecto Saludos desde Venezuela, Edo Tachira.
Quisiera aprovechar y preguntarte lo siguiente.
Actualmente estoy trabando en un proyecto y necesito leer voltajes AC desde 0 hasta 300 V en AC es para saber si hay algún tipo de metodo en crear un sensor que lo pueda conectar al Arduino. Seria algo de 300V AC a 5V DC asi poder utilizar la entrada analogica con esos valores y crear un Voltimetro AC desde 0 a 300v ac. Seria de mucha ayuda alguna sugerencia.
Muchas Gracias Amigo
Hola amigo Omar.
En primer lugar te diré que leído tu consulta un par de veces y no veo que indiques que no puedas
disponer de un par de escalas de tensión, porque no?. Entonces, partiendo de que utilizaríamos
dos escalas; una de 0V a 150V y una segunda de 150V a 300V.
Para tensiones continuas, salvo error u omisión tendríamos:
Para la primera escala.
Esto es orientativo, ya que tu hablas de tensiones alternas, lo que tendrás que considerar.
Espero te sirva.
Saludos de Vicente.
Hola:
A ver si me puedes ayudar. Quiero medir el voltaje de una batería y a la vez el voltaje de un panel fotovoltaico. El problema que me estoy encontrando es que no puedo medir los dos a la vez por que se cruzan por estar conectados ambos a un regulador solar.
Probé a poner unos diodos pero no me ha funcionado.
Te paso una imagen de la conexiones
http://nergiza.com/foro/attachments/a20160712_solar_bb-png.262/
También hice la consulta allí pero se ve que nadie sabe como solucionarlo.
http://nergiza.com/foro/threads/medir-voltages-sistema-fotovoltaico-con-arduino.820/
¿Se te ocurre como puedo hacer?
Hola Dani.
Por el esquema/circuito que adjuntas, puede que explique los problemas que tienes.
En primer lugar, las masas no están unidas y eso es un nido de problemas que ya puedes imaginar.
Por otra parte y en principio, no son necesarios los electrolíticos, ya que enmascaran las medidas.
Los reguladores, no comprendo que has dibujado, ya que supongo que deben regular Reg1 la tensión
del panel a la batería y entonces el Reg2 que función hace?
En principio debes unir todas las masas, y diré más ya que pueden llevar altos amperajes todas unidas
en un mismo punto, si es posible. Algo parecido a esto:
Hola:
sólo tengo un regulador, es como este:
https://chilesale.cl/wp-content/uploads/2015/07/Controlador-regulador-solar-30a-chilesale-a1.jpg
Sobre el esquema, a ver si entendí bien, sería algo como esto?
https://s32.postimg.org/kjgpwf34l/a20160712_solar_erro_bb_03.png
Hola Dani.
Desconozco es regulador, aunque es de relativa importancia. El siguiente es una adaptación del circuito que tu comentas.
Espero te sirva de orientación. Volt. 1 mide la tensión de batería y Volt. 2 mide la tensión del panel. Fíjate que todas las masas son la misma y están cada una en su sitio (en tu circuito algunas masas no conectan con nada, sobre todo la resistencia de 10K).
Saludos de Vicente.
Muchas gracias Vicente!
El regulador en un aparato que gestiona la carga de la batería con los paneles solares. Se encarga de dejar de cargar la batería cuando ya está cargada y tambien evitar que se descargue más de la cuenta.
Un detalle, en tú esquema, como se llama el componente une los positivos de la placa y la batería? (el de 3 patas).
Muchas gracias nuevamente.
Hola,
Muy buen trabajo, felicidades!
De momento solo he leído el proyecto, intentaré llevar-lo a cabo en breve. Pero tengo algunas dudas.
Me interesa medir el voltaje de baterias de coche (12V , 90A), me puede servir?
Si arduino solo lee de 0 a 5 V, luego hago una proporción para saber el voltaje?
Saludos,
Muchas gràcias
Hola Marc.
Gracias por tus palabras. Respecto de tu consulta; 1) la tensión máxima que puede medir el voltímetro es una relación directa de los valores de R1 y R2, esto lo puedes verificar en el código donde dice:
Serial.println("DC VOLTMETER");Serial.print("Maximum Voltage: ");
Serial.print((int)(v1 / (r2 / (r1 + r2))));
Es decir, que con los valores del código, claramente puede llegar hasta los 50V.
En cuanto a tu segunda pregunta, creo que es cuestión de que debes leer el artículo con más atención. Se trata de un divisor de tensión formado por R1 y R2, a cuyos extremos aplicaremos la tensión que queremos mesurar y el propio divisor hace lo que tu llamas «la proporción» (disculpa, sin ánimo de ofender).
Espero haber aclarado tus dudas, si necesitas más aclaraciones estoy a la espera de poder ayudarte.
Saludos.
buenas queria saber de que manera puedo hacer para que el voltimetro mida tambien voltajes negativos gracias
Hola Santiago.
Voy a intentar responder tus dudas.
El conversor A/D de Arduino, es de 10Bits, esto en pocas palabras es que, para convertir un valor analógico a digital, lo que hace es dividir el máximo valor por 1024 pasos, de modo que 0V equivale a 0(pasos) y 5V (que es el máximo que puede leer Arduino) equivale a 1024 (pasos) , para mayor aclaración debes consultar en google ):
A tu segunda consulta no tengo suficiente información, pero todo apunta a que tienes alguna operación descontrolada, revisa tus operaciones y los paréntesis (suelen pasar dar malos resultados) o puede que el valor de tus resistencias no sea el adecuado.
En cuanto al valor de 4’98V que aparece en el código, se refiere a la tensión real del Arduino que, en teoría debería ser 5V. Luego todos los valores que se realizan en las operaciones se ven influenciados por este valor. Si te refieres al valor mesurado de 4’92 que se muestra en la imagen del monitor Serial, es la tensión mesurada en un paquete de pilas alcalinas viejas que tenía en ese momento.
Espero haber respondido a tus preguntas.
Saludos.
Hola, muy buenas, tengo varias dudas, si fuera tan amable de resolverlas le estaría agradecido:
He realizado la primera versión, es decir, utilizado el monitor serial para visualizar los valores.
En primer lugar, ud. divide el producto de v1 por el valor analógico A0, entre 1024, ¿Que significa ese valor?
En segundo lugar, estoy midiendo una pila de 1.5V y en pantalla el resultado que me da es de 17,54V, y no logro averiguar por que.
En el ejemplo que usted muestra en el caso 1(se ven valores de 4.92V…), ¿Que es lo que se ha medido?.
Muchas gracias de antemano.
Hola, estoy interesada en realizar este proyecto, quisiera saber como serian las conexiones si usare un I2C y si la programacion cambiaria, la verdad no soy muy buena en programacion. Por otra parte eh leido el comentario de arriba y veo que menciona el uso de un Attiny2313, esto para que se usaria. Y a que se refiere con que no ha probado aun el anttiny. Quisiera saber si podria respondar mas dudas que tengo sobre el proyecto,
Hola Amy Velasco.
Me parece bien que te interese el proyecto del voltímetro. El tema trata de poder intercalar un voltímetro en una fuente de alimentación, la cuestión se ha ido extendiendo por comentarios de todas partes y he pensado en ampliar el proyecto añadiendo un amperímetro, ya que haría más completo el proyecto. Alguno ha pedido que muestre los vatios (W) que se representan en la salida, claro que en algún momento he de poner fin al proyecto.
Por otra parte me preguntas por el I2C; se trata de un sistema de comunicación con dos hilos que para más detalle puedes leer en este enlace «https://hispavila.com/total/3ds/atmega/intro_i2c.html», además te interesa saber que es el Attiny2313; se trata de unos microcontroladores muy pequeños que permiten realizar algunas tareas por sí solos ya que son más económicos a la hora de realizar ciertos proyectos, el haber cambiado de tipo al Attiny85 es debido a que siendo más pequeño creo que me permite realizar el mismo proyecto en un espacio menor.
En cuanto a si puedes consultar, no hay inconveniente, si puedo ayudar siempre estoy dispuesto.
Espero haber dado respuesta a tus consultas.
Hola Karen Isabel
Tienes toda la razón, no he mostrado el conexionado de la pantalla LCD y eso es debido a que el proyecto no está aún terminado.
El caso es que la conexión del LCD puede ser usando un I2C con cuatro hilos o con los seis habituales que se usan en cualquier montaje mostrado en otros artículos.
Ese es el motivo por el que no puse dicho conexionado. En la figura 2, tienes un esbozo de como se puede hacer. El siguiente es un esquema de las conexiones previstas (no lo he probado todavía), estaba previsto usar un Attiny2313 y creo que con un Attiny85 sería posible.
Espero que te sirva entre tanto termino el proyecto.
hola me interesa el armado q hace,pero me gustaría saber la conexión del display al arduino q pines debo utilizar? No lo detalla ahí sí me podría facilitar algo más detallado por favor
Excelente trabajo