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!.
Hola me he percarado de varios errores en los Voltímetro DC.
Código de ejemplo para visualizar el voltaje, versión 3.
Repasalo ya que no funciona el código.
Pero corriegiendo los errores si que Complila perfectamente.
No lo he montado ya que despues de ver los errores no parece que pueda funcionar bien.
Saludos
Cuidate mucho.
Hola Copernico Andrade.
Tienes cierta razón, no compila bien debido a un error de bulto en la línea 57, donde dice:
if (index < =20) // para que no muestre los primeras lecturasDebe decir:
if (index <= 20) // para que no muestre los primeras lecturasUn sutil espacio entre '<' y '=' que debes corregir para que compile sin errores. Lamento el error, ya está corregido. Saludos y cuídate.
Muchas gracias por el post, tengo una pregunta, yo tengo un circuito que incluye un arduino nano y quisiera indicar cuando el circuito se le tiene que recargar la bateria, como podria lograr esto?
Muchas gracias
Hola Cesar.
Esa es una buena idea, el problema que se presenta es relativo ya que se tiene que comparar dos tensiones a extremos de una ‘resistencia’ que indique si hay consumo y en que porcentaje se encuentra la batería. Esto se debe tratar con más detalle y realizando algunos cálculos que se requieren, por lo tanto, se trata de un artículo dedicado al tema.
Saludos y cuidate.
Se que paso tiempo desde esta publicación, pero es justo lo que estaba buscando. Quiero intentar convertir la lectura de voltimetro en un tacometro para la motocicleta. Tomando la señal que le llegaba al tacometro original desde la ECU. Creo que llega en voltaje la señal. de todos modos me gusto mucho el articulo, muy bien redactado para gente sin conocimientos profundos de electronica. muchas gracias.
Hola muy buen post lo eh realizado y noto un problema al momento de realizar mediciones pequeñas por ejemplo pilas AA o AAA al medir con el mulltimetro me marca 1.3V y al usar el arduino me marca 1.1V es muy pequeña la diferencia pero pues se pierde presicion, y este problema desaparece en mediciones mayores a 5V donde la presicion es casi del 98% , a que se puede deber esa diferencia de lecturas?
Hola Franco Chacon
Es posible que se produzca un desvío de unos mV, debido a factores como ajustes de la formula a tu montaje sin embargo, ese desvío debería ser similar en toda la escala, es decir, si tu escala de tensión máxima es de 20V, el desvío debe ser aproximadamente igual en toda la escala. Si quieres hacer una prueba, considera realizar la formula para una escala menor, por ejemplo, 0 a 10V en esa escala puedes ajustar mejor las tensiones leídas, luego amplías la escala hasta los 15V y comparas los desvíos tratando entonces de ajustar denuevo la formula. De esta manera llegarás a un ajuste que te será de mayor precisión, pues, en muchas ocasiones el factor que más influye es la propia escala que es muy amplia, piensa que el convertidor AD de Arduino es muy sencillo y la precisión es relativa a este convertidor.
Espero que te sirva esta aclaración y te ayude a mejorar tu voltímetro.
Un saludo.
Hola franco chacon.
Siento mucho la tardanza en leer tu post, disculpa.
La precisión es relativa a los componentes que utilizamos, de todos modos, también depende del rango en que hayas realizado la medida, trata de utilizar un rango más bajo y en último caso, revisa la formula del código para lograr una mayor precisión..
Repito, siento el retraso en la respuesta.
Saludos y cuídate.
Magnifico, creo que lo usaré para controlar unas baterías. Mil gracias
Hola David.
Esa era la primera idea de este artículo. Me alegra que te sirva.
Hola
Quería saber que significaba sampleBVal en Anexo 1 fila 37, que luego lo utiliza en la funcion sampleBVal = sampleBVal + val
Hola Nacho, en respuesta a tu consulta te diré que:
Para aplicar un valor a una variable (en este caso sampleBVal), primero declaramos la variable sampleBVal, en la cual depositamos el valor leído.
Las variables pueden ser globales, las cuales las pueden ‘ver’ todas las funciones del programa y las variable locales que tan sólo se utilizan en la función en la que se haya declarado.
En concreto sampleBVal quiere decir ‘muestra batería valor’ es castellano sería, muestra valor batería.
Disculpa …. Detecta la polaridad?