Voltímetro preciso en arduino. Entradas analógicas y resistencias pull-up. Escribir y leer datos del puerto serie
Entradas analógicas de la placa Arduino.
Pagar Arduino UNO Contiene 6 entradas analógicas diseñadas para medir señales de voltaje. Sería más correcto decir que los 6 pines de la placa pueden funcionar tanto en modo de salida discreta como de entrada analógica.
Estos pines están numerados del 14 al 19. Inicialmente están configurados como entradas analógicas y se puede acceder a ellos usando los nombres A0-A5. Se pueden configurar en modo de salida discreta en cualquier momento.
pinMode(A3, SALIDA); // configuración del modo de salida discreta para A3
escritura digital (A3, BAJO); // configuración de salida A3 baja
Para regresar al modo de entrada analógica:
modopin(A3, ENTRADA); // configuración del modo de entrada analógica para A3
Entradas analógicas y resistencias pull-up.
Las resistencias pull-up están conectadas a los pines de entrada analógica, así como a los pines discretos. Estas resistencias se activan usando el comando
escritura digital (A3, ALTA); // Encienda la resistencia pull-up para la entrada A3.
El comando debe aplicarse a un pin configurado en modo de entrada.
Hay que recordar que la resistencia puede afectar el nivel de la señal de entrada analógica. La corriente de la fuente de alimentación de 5 V, a través de la resistencia pull-up, provocará una caída de voltaje en la resistencia interna de la fuente de señal. Entonces es mejor desconectar la resistencia.
Convertidor analógico a digital de placa Arduino.
La medición de tensión real en las entradas se realiza Conversor analógico a digital(ADC) con un interruptor de 6 canales. El ADC tiene una resolución de 10 bits, que corresponde al código en la salida del convertidor 0...1023. El error de medición no supera las 2 unidades del dígito menos significativo.
Para mantener la máxima precisión (10 dígitos), es necesario que resistencia interna La fuente de señal no superó los 10 kOhm. Este requisito es especialmente importante cuando se utilizan divisores de resistencia conectados a las entradas analógicas de la placa. La resistencia de las resistencias divisorias no puede ser demasiado alta.
Funciones del software de entradas analógicas.
int analogRead(puerto)
Lee el valor de voltaje en la entrada analógica especificada. Rango de voltaje de entrada desde 0 hasta el nivel de fuente voltaje de referencia(a menudo 5V) se convierte en un código de 0 a 1023.
Con una tensión de referencia de 5 V, la resolución es 5 V/1024 = 4,88 mV.
La conversión tarda aproximadamente 100 μs.
int inputCod; // código de voltaje de entrada
voltaje de entrada flotante; // tensión de entrada en V
inputCod= analogRead(A3); // tensión de lectura en la entrada A3
voltaje de entrada = ((flotante) bacalao de entrada * 5. / 1024.); // conversión de código a voltaje (V)
referencia análoga nula (tipo)
Establece el voltaje de referencia para el ADC. Se define valor máximo voltaje en la entrada analógica, que el ADC puede convertir correctamente. El valor de la tensión de referencia también determina el factor de conversión de código a tensión:
Voltaje de entrada = código ADC * voltaje de referencia / 1024.
El argumento de tipo puede tomar los siguientes valores:
- PREDETERMINADO: el voltaje de referencia es igual al voltaje de suministro del controlador (5 V o 3,3 V). Para Arduino UNO R3 – 5V.
- INTERNO – voltaje de referencia interno 1,1 V para placas con controladores ATmega168 y ATmega328, para ATmega8 – 2,56 V.
- INTERNAL1V1 – tensión de referencia interna 1,1 V para controladores arduino Mega.
- INTERNAL2V56: voltaje de referencia interno de 2,56 V para controladores Arduino Mega.
- EXTERNO - fuente externa Tensión de referencia, conectada a la entrada AREF.
Referencia analógica(INTERNA); // El voltaje de referencia es 1,1 V.
Voltímetro de dos canales en Arduino.
Como ejemplo del uso de funciones de entrada analógica, creemos un proyecto para un voltímetro digital simple en Arduino. El dispositivo debe medir voltajes en dos entradas analógicas de la placa y transmitir los valores medidos a la computadora a través de Puerto serial. Usando este proyecto como ejemplo, mostraré los principios de la creación. sistemas simples medir y recopilar información.
Decidamos que el voltímetro debe medir el voltaje dentro del rango de al menos 0...20 V y desarrollemos un circuito para conectar las entradas del voltímetro a la placa Arduino UNO.
Si configuramos el voltaje de referencia en 5 V, entonces las entradas analógicas de la placa medirán el voltaje dentro de 0...5 V. Y necesitamos al menos 0...20 V. Esto significa que necesitamos usar un divisor de voltaje.
El voltaje en la entrada y salida del divisor está relacionado por la relación:
Usalida = (Uentrada / (R1 + R2)) * R2
Relación de transmisión:
K = Usalida / Uentrada = R2 / (R1 + R2)
Necesitamos una relación de transferencia de 1/4 (20 V * 1/4 = 5 V).
Para mantener la máxima precisión (10 bits), es necesario que la resistencia interna de la fuente de señal no supere los 10 kOhm. Por tanto, elegimos la resistencia R2 igual a 4,22 kOhm. Calculamos la resistencia de la resistencia R1.
0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0,25 – 4,22 = 12,66 kOhmios
Encontré resistencias con una resistencia de 15 kOhm con el valor más cercano. Con resistencias R1 = 15 kOhm y R2 = 4,22:
5/(4,22/(15 + 4,22)) = 22,77V.
El circuito del voltímetro basado en Arduino se verá así. 
Hay dos divisores de tensión conectados a las entradas analógicas A0 y A1. Los condensadores C1 y C2, junto con las resistencias divisorias, forman filtros de paso bajo que eliminan el ruido de alta frecuencia de las señales.
Monté este circuito en una placa de pruebas.
Conecté la primera entrada del voltímetro a una fuente de alimentación regulada y la segunda a la fuente de alimentación de 3,3 V de la placa Arduino. Para monitorear el voltaje, conecté un voltímetro a la primera entrada. Todo lo que queda es escribir el programa.
Un programa para medir voltaje usando una placa Arduino.
El algoritmo es simple. Necesario:
- lea el código ADC dos veces por segundo;
- convertirlo en voltaje;
- enviar valores medidos a través del puerto serie a una computadora;
- programa de monitorización de puertos IDE de Arduino mostrar los valores de voltaje obtenidos en la pantalla de la computadora.
Te daré un bosquejo completo del programa de inmediato.
// programa de medición de voltaje
// en las entradas analógicas A0 y A1
#incluir
tiempo del período de medición
#definir R1 15. // resistencia de la resistencia R1
#definir R2 4.22 // resistencia de la resistencia R2
flotar u1, u2; // voltajes medidos
configuración nula() (
Serie.begin(9600); //
MsTimer2::inicio(); // habilitar interrupción
}
bucle vacío() (
// período 500 ms
si (timeCount >= MEASURE_PERIOD) (
cuentatiempo= 0;
//
// leer el código del canal 2 y convertirlo a voltaje
u2= ((flotante)analogRead(A1)) * 5. / 1024. / R2 * (R1 + R2);
// transferencia de datos a través del puerto serie
Serie.print("U1 = "); Serie.print(u1, 2);
Serie.print(" U2 = "); Serie.println(u2, 2);
}
}
// procesamiento de interrupción 1 ms
Interrupción del temporizador vacío() (
cuentatiempo++;
}
Permítanme explicar la línea en la que el código ADC se convierte en voltaje:
// leer el código del canal 1 y convertirlo a voltaje
u1= ((flotante)analogRead(A0)) * 5. / 1024. / R2 * (R1 + R2);
- Se lee el código ADC: analogRead(A0) .
- Convertido explícitamente a formato de punto flotante: (flotante).
- Convertido a voltaje en la entrada analógica: * 5. / 1024. El punto al final de los números indica que se trata de un número de punto flotante.
- Se tiene en cuenta el coeficiente de transmisión del divisor: / R2 * (R1 + R2).
Cargue el programa en la placa, inicie el monitor. Puerto serial.
Dos barras móviles muestran los valores de las tensiones medidas. Todo está funcionando.
Medición del valor medio de la señal.
Conectemos el primer canal de nuestro voltímetro a una fuente de voltaje con un alto nivel de ondulación. Veremos esta imagen en el monitor.
Los valores de voltaje del primer canal en la pantalla del monitor cambian y saltan constantemente. Y las lecturas del voltímetro de control son bastante estables. Esto se debe a que el voltímetro de referencia mide el valor promedio de la señal, mientras que la placa Arduino lee muestras individuales cada 500 ms. Naturalmente, el momento de leer el ADC cae en diferentes puntos señal. Y cuando nivel alto La amplitud de la pulsación en estos puntos es diferente.
Además, si lee la señal en muestras raras separadas, cualquier ruido impulsivo puede introducir un error significativo en la medición.
La solución es tomar varias muestras frecuentes y promediar el valor medido. Para esto:
- en el manejador de interrupciones leemos el código ADC y lo sumamos con las muestras anteriores;
- contar el tiempo de promediación (número de muestras promediadas);
- cuando se alcanza el número especificado de muestras, guardamos el valor total de los códigos ADC;
- Para obtener el valor promedio, divida la suma de los códigos ADC por el número de muestras promedio.
Problema de un libro de texto de matemáticas de octavo grado. Aquí hay un boceto del programa, un voltímetro de valor promedio de dos canales.
// programa de medida de media tensión
// en las entradas analógicas A0 y A1
#incluir
#definir MEDIDA_PERIODO 500 // tiempo del período de medición
#definir R1 15. // resistencia de la resistencia R1
#definir R2 4.22 // resistencia de la resistencia R2
int cuentatiempo; // contador de tiempo
suma larga U1, suma U2; // variables para sumar códigos ADC
promedio largo U1, promedio U2; // suma de códigos ADC (valor promedio * 500)
bandera booleanaListo; // indicador de preparación de los datos de medición
configuración nula() (
Serie.begin(9600); // Inicializar el puerto, velocidad 9600.
MsTimer2::set(1, timerInterupt); // interrupciones del temporizador, período 1 ms
MsTimer2::inicio(); // habilitar interrupción
}
bucle vacío() (
si (banderaListo == verdadero) (
banderaListo=falso;
// Conversión a voltaje y transferencia a computadora.
Serie.print("U1 = ");
Serial.print((float)avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
Serie.print(" U2 = ");
Serial.println((float)avarageU2 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
}
}
// procesamiento de interrupción 1 ms
Interrupción del temporizador vacío() (
cuentatiempo++; // +1 contador de muestra promedio
sumU1+= analogRead(A0); // sumando códigos ADC
sumU2+= analogRead(A1); // sumando códigos ADC
// comprobar el número de muestras promedio
si (timeCount >= MEASURE_PERIOD) (
cuentatiempo= 0;
promedioU1= sumaU1; // sobrecarga de valor promedio
promedioU2= sumaU2; // sobrecarga de valor promedio
sumaU1= 0;
sumaU2= 0;
banderaListo= verdadero; // El resultado de la medición de señal está listo.
}
}
En la fórmula para convertir el código ADC en voltaje, se agregó /500, el número de muestras. Cargue, inicie el monitor de puerto (Cntr+Shift+M).
Ahora, incluso con un nivel significativo de pulsación, las lecturas cambian en centésimas. Esto se debe únicamente a que el voltaje no está estabilizado.
El número de muestras deberá elegirse teniendo en cuenta:
- el número de muestras determina el tiempo de medición;
- cómo numero mayor muestras, menor será la influencia del ruido.
La principal fuente de interferencia en señales análogas es una red de 50 Hz. Por lo tanto, es aconsejable elegir un tiempo promedio que sea múltiplo de 10 ms (el tiempo de medio ciclo de una red de 50 Hz).
Optimización de cálculos.
Los cálculos en coma flotante simplemente consumen los recursos de un microcontrolador de 8 bits. Cualquier operación de punto flotante requiere desnormalización de mantisa, operación de punto fijo, normalización de mantisa, corrección de orden... Y todas las operaciones con números de 32 bits. Por tanto, es necesario minimizar el uso de cálculos de punto flotante. Te diré cómo hacer esto en las siguientes lecciones, pero al menos optimicemos nuestros cálculos. El efecto será significativo.
En nuestro programa, la conversión del código ADC en voltaje se escribe de la siguiente manera:
(flotante)promedioU1 / 500. * 5. / 1024. / R2 * (R1 + R2)
Hay muchísimos cálculos aquí, todos con punto flotante. Pero La mayoría de cálculos – operaciones con constantes. Parte de la línea:
/ 500. * 5. / 1024. / R2 * (R1 + R2)
(flotante)promedioU1 * 0.00004447756
Los propios compiladores inteligentes reconocen los cálculos con constantes y los calculan en la etapa de compilación. Tengo una pregunta sobre qué tan inteligente es el compilador de Andruino. Decidí comprobarlo.
escribí programa corto. Realiza un ciclo de 10.000 pasadas y luego transmite el tiempo de ejecución de esos 10.000 ciclos a la computadora. Aquellos. le permite ver el tiempo de ejecución de las operaciones colocadas en el cuerpo del bucle.
// verificación de optimización de cálculo
enterox= 876;
flotar y;
recuento de enteros sin firmar;
tiempo largo sin firmarActual, tiempoPrev;
configuración nula() (
Serie.begin(9600);
}
bucle vacío() (
contar++;
// y= (flotante)x / 500. * 5. / 1024. / 4,22 * (15. + 4,22);
// y= (flotante)x * 0.00004447756;
si (cuenta >= 10000) (
contar= 0;
tiempoActual= milis();
Serial.println(tiempoActual - tiempoAnterior);
tiempoAnterior= tiempoActual;
}
}
En la primera opción, cuando las operaciones de punto flotante en el bucle se comentan y no se ejecutan, el programa produjo un resultado de 34 ms.
Aquellos. Se completan 10.000 bucles vacíos en 34 ms.
Luego abrí la línea:
y= (flotante)x / 500. * 5. / 1024. / 4,22 * (15. + 4,22);
repite nuestros cálculos. Resultado de 10.000 pasadas en 922 ms o
(922 – 34) / 10.000 = 88,8 µs.
Aquellos. esta línea de cálculos de punto flotante tarda 89 µs en completarse. Pensé que habría más.
Ahora cerré esta línea con un comentario y abrí la siguiente, multiplicando por una constante previamente calculada:
y= (flotante)x * 0,00004447756;
Resultado de 10.000 pasadas en 166 ms o
(166 – 34) / 10.000 = 13,2 µs.
Resultado asombroso. Ahorramos 75,6 μs por línea. Lo completamos casi 7 veces más rápido. Tenemos 2 líneas de este tipo, pero puede haber muchas más en el programa.
Conclusión: los cálculos con constantes deben realizarse usted mismo en una calculadora y utilizarse en programas como coeficientes ya preparados. El compilador Arduino no los calculará en la etapa de compilación. En nuestro caso deberíamos hacer esto:
#definir ADC_U_COEFF 0.00004447756 // factor de conversión del código ADC a voltaje
Serial.print((float)avarageU1 * ADC_U_COEFF, 2);
La opción óptima para el rendimiento es transferir el código ADC a la computadora y, junto con él, todos los cálculos de punto flotante. En este caso, la computadora debe recibir datos. programa especializado. El monitor de puerto del IDE de Arduino no funcionará.
Hablaré sobre otras formas de optimizar los programas Arduino en lecciones futuras según sea necesario. Pero sin resolver este problema es imposible desarrollar programas complejos en un microcontrolador de 8 bits.
Ha aparecido otra lección en el sitio (
Este artículo proporciona esquema interesante para los amantes de los experimentos y arduino. Presenta una sencilla voltímetro digital, que puede medir de forma segura el voltaje CC en el rango de 0 a 30 V. La propia placa Arduino puede ser alimentada por fuente estándar 9v.
Como sabes, utilizando la entrada analógica de Arduino puedes medir voltaje de 0 a 5 V (con un voltaje de referencia estándar de 5 V). Pero este rango se puede ampliar utilizando un divisor de voltaje.
El divisor reduce el voltaje medido a un nivel aceptable para la entrada analógica. Luego, un código especialmente escrito calcula el voltaje real.
El sensor analógico en Arduino detecta el voltaje en la entrada analógica y lo convierte en formato digital, percibido por el microcontrolador. Conectamos un divisor de tensión formado por las resistencias R1 (100K) y R2 (10K) a la entrada analógica A0. Con estos valores de resistencia se pueden suministrar hasta 55 V al Arduino, ya que el coeficiente de división es en este caso resulta 11, entonces 55V/11=5V. Para asegurarse de que las mediciones sean seguras para la placa, es mejor medir el voltaje en el rango de 0 a 30 V.
Si las lecturas de la pantalla no coinciden con las lecturas verificadas del voltímetro, use un multímetro digital de precisión para encontrar valores exactos R1 y R2. En este caso, en el código deberá reemplazar R1=100000.0 y R2=10000.0 con sus propios valores. Luego debes verificar la fuente de alimentación midiendo el voltaje en la placa entre 5V y GND. El voltaje puede ser 4,95 V. Luego, en el código vout = (valor * 5,0) / 1024,0 debes reemplazar 5,0 por 4,95. Es recomendable utilizar resistencias de precisión con un error no superior al 1%. Tenga en cuenta que los voltajes superiores a 55 V pueden causar placa arduino¡Fuera de servicio!
#incluir
Elementos utilizados:
placa arduino uno
Resistencia 100 KOhmios
Resistencia 10 KOhmios
resistencia de 100 ohmios
Potenciómetro 10KOhm
Pantalla LCD 16×2
Datos iniciales y revisión.
Entonces en este punto tenemos un voltímetro. voltaje CC con un límite de 0..20V (ver apartado anterior). Ahora le agregamos un amperímetro de 0..5a. Para hacer esto, modificamos ligeramente el circuito: se convertirá en un circuito de paso, es decir, tiene tanto una entrada como una salida.
Quité la parte relacionada con la pantalla LCD; no cambiará. En principio, el principal elemento nuevo es una derivación Rx de 0,1 ohmios. La cadena R1-C1-VD1 sirve para proteger la entrada analógica. Tiene sentido instalarlo en la entrada A0. Dado que asumimos corrientes bastante grandes, existen requisitos de instalación: las líneas eléctricas deben estar hechas con un cable bastante grueso y conectadas directamente a los terminales de derivación (en otras palabras, soldadas); de lo contrario, las lecturas estarán lejos de la realidad. También hay una nota sobre la corriente: en principio, un voltaje de referencia de 1,1 V permite registrarlo en la derivación. Corriente de 0,1 ohmios hasta 11 amperios con una precisión ligeramente peor que 0,01a, pero cuando dicho voltaje cae a través de Rx, la potencia liberada superará los 10 W, lo cual no es nada divertido. Para resolver el problema, puedes usar un amplificador con una ganancia de 11 usando un amplificador operacional de alta calidad y una derivación de 10 mOhm (0,01 ohmios). Pero por ahora no nos complicaremos la vida y simplemente limitaremos la corriente a 5A (en este caso, la potencia Rx se puede seleccionar del orden de 3-5 W).
En esta etapa, me esperaba una sorpresa: resultó que el ADC del controlador tenía un desplazamiento cero bastante grande, aproximadamente -3 mV. Es decir, el ADC simplemente no ve señales de menos de 3 mV, y las señales de un nivel ligeramente superior son visibles con una inexactitud característica de -3 mV, lo que estropea la linealidad al comienzo del rango. Una búsqueda rápida no dio ninguna referencia obvia a tal problema (un desplazamiento cero es normal, pero debería ser significativamente menor), por lo que es muy posible que se trate de un problema con una instancia Atmega 328 específica. La solución que elegí fue. doble - en voltaje - un paso de software al comienzo del rango (la pantalla comienza en 0,06 voltios), para corriente - una resistencia pull-up al bus de 5V. La resistencia está indicada por una línea de puntos.
Fuente
La versión completa de este voltímetro (en la versión I2C) se puede descargar desde el enlace al final del artículo. A continuación mostraré los cambios en el código fuente. Se agregó lectura de la entrada analógica A1 con el mismo promedio que para el voltímetro. En esencia, este es el mismo voltímetro, solo que sin divisor, y obtenemos amperios usando la fórmula de Ohm: I = U/Rx (por ejemplo, si la caída de voltaje en Rx = 0,01 V, entonces la corriente es 0,1A). También presenté la constante de ganancia actual AmpMult, para el futuro. Probablemente será necesario hacer coincidir la constante AmpRx con la resistencia en derivación para tener en cuenta la inexactitud de la resistencia en derivación. Bueno, dado que este ya es un voltímetro y todavía queda espacio en la pantalla del 1602, queda por mostrar el consumo de energía actual en vatios, obteniendo una funcionalidad adicional simple.
.... // Entrada analógica #define PIN_VOLT A0 #define PIN_AMP A1 // Tensión de referencia interna (seleccionar) const float VRef = 1,10; // Entrada del coeficiente divisor resistivo (Rh + Rl) / Rl. EN 0,2) InVolt += 3; // Convertir a voltios (En: 0..1023 -> (0..VRef) escalado por Mult) float Volt = InVolt * VoltMult * VRef / 1023; amplificador flotante = InAmp * VRef / AmpMult / AmpRx / 1023; // Para tener en cuenta la caída en la derivación, descomente 2 líneas //float RxVolt = InAmp * VRef / 1023 / AmpMult; // Voltio -= RxVolt; vatio flotante = voltio * amperio; // Datos de salida lcd.setCursor (8, 0); lcd.print(vatios); lcd.imprimir("W "); lcd.setCursor(0, 1); lcd.print(Voltios); lcd.imprimir("V "); lcd.setCursor(8, 1); lcd.print(Amperio); lcd.imprimir("A "); )
Enlaces
- Biblioteca LiquidCrystal_I2C, que le permite configurar el pinout
Se presenta un diagrama útil para quienes gustan de experimentar con Arduino. Este es un voltímetro digital simple que puede medir de manera confiable el voltaje CC en el rango de 0 a 30 V. La placa Arduino, como es habitual, puede funcionar con una batería de 9V.
Como probablemente sepa, las entradas analógicas de Arduino se pueden usar para medir voltaje CC en el rango de 0 a 5 V y este rango se puede aumentar.
usando dos resistencias como divisor de voltaje. El divisor reducirá el voltaje medido al nivel de las entradas analógicas de Arduino. Y luego el programa calculará el valor de voltaje real.
El sensor analógico de la placa Arduino detecta la presencia de voltaje en la entrada analógica y lo convierte en formulario digital para su posterior procesamiento por parte del microcontrolador. En la figura, se suministra voltaje a la entrada analógica (A0) a través de un divisor de voltaje simple que consta de resistencias R1 (100 kOhm) y R2 (10 kOhm).
Con estos valores del divisor, la placa Arduino puede recibir voltaje de 0 a
55V. En la entrada A0 tenemos la tensión medida dividida por 11, es decir 55V / 11=5V. En otras palabras, al medir 55V en la entrada de Arduino tenemos un máximo valor permitido 5V. En la práctica, es mejor escribir el rango "0 - 30 V" en este voltímetro para que permanezca
¡Margen de seguridad!
Notas
Si las lecturas de la pantalla no coinciden con las lecturas de un voltímetro industrial (de laboratorio), entonces es necesario medir el valor de las resistencias R1 y R2 con un instrumento preciso e insertar estos valores en lugar de R1=100000,0 y R2=10000,0. en el código del programa. Luego debes medir el voltaje real entre los pines de 5V y “Tierra” de la placa Arduino con un voltímetro de laboratorio. El resultado será un valor inferior a 5V, por ejemplo, será 4,95V. Este valor real debe insertarse en la línea de código.
vout = (valor * 5,0) / 1024,0 en lugar de 5,0.
Además, intente utilizar resistencias de precisión con una tolerancia del 1%.
Las resistencias R1 y R2 brindan cierta protección contra aumentos de voltaje de entrada. Sin embargo, recuerde que cualquier voltaje superior a 55 V puede dañar la placa Arduino. Además, este diseño no proporciona otros tipos de protección (contra sobretensiones, inversión de polaridad o sobretensión).
Programa de voltímetro digital
/*
Voltímetro CC
Un Arduino DVM basado en el concepto de divisor de voltaje
T.K.Hareendran
*/
#incluir
Lcd de cristal líquido (7, 8, 9, 10, 11, 12);
int entrada analógica = 0;
salida flotante = 0,0;
vin flotante = 0,0;
flotador R1 = 100000,0; // resistencia de R1 (100K) -ver texto!
flotador R2 = 10000,0; // resistencia de R2 (10K) – ¡ver texto!
valor entero = 0;
configuración nula())(
pinMode(entrada analógica, ENTRADA);
lcd.comenzar(16, 2);
lcd.print(“Voltímetro CC”);
}
bucle vacío()
// lee el valor en la entrada analógica
valor = lectura analógica (entrada analógica);
vout = (valor * 5,0) / 1024,0; //ver texto
vin = vsal / (R2/(R1+R2));
si (vin)<0.09) {
vin=0.0;//declaración para anular lecturas no deseadas!
}
lcd.setCursor(0, 1);
lcd.print(“ENTRADA V= “);
lcd.imprimir(vin);
retraso(500);
}
Diagrama esquemático del voltímetro Arduino.
Lista de componentes
placa arduino uno
resistencia de 100 kiloohmios
resistencia de 10 kiloohmios
resistencia de 100 ohmios
Resistencia recortadora de 10 kOhm
Pantalla LCD 16?2 (Hitachi HD44780)
¡Hola Habr! Hoy quiero continuar con el tema del “cruce” de arduino y android. En la publicación anterior hablé de una máquina bluetooth, y hoy hablaremos de un voltímetro bluetooth de bricolaje. Otro de estos dispositivos puede denominarse voltímetro inteligente, voltímetro "inteligente" o simplemente voltímetro inteligente, sin comillas. El apellido es incorrecto desde el punto de vista de la gramática rusa, sin embargo, se encuentra a menudo en los medios. Habrá una votación sobre este tema al final del artículo, pero sugiero comenzar con una demostración del funcionamiento del dispositivo para comprender de qué se tratará el artículo.
Descargo de responsabilidad: el artículo está destinado al entusiasta promedio de Arduino que generalmente no está familiarizado con la programación para Android, por lo tanto, como en el artículo anterior, crearemos una aplicación para un teléfono inteligente utilizando el entorno de desarrollo visual para aplicaciones de Android. Inventor de aplicaciones 2.
Para hacer un voltímetro bluetooth de bricolaje, necesitamos escribir dos programas relativamente independientes: un boceto para Arduino y una aplicación para Android. Comencemos con un boceto.
Primero, debe saber que existen tres opciones principales para medir voltaje usando Arduino, independientemente de dónde necesite enviar la información: al puerto COM, a una pantalla conectada al Arduino o a un teléfono inteligente.
Primer caso: mediciones de tensión hasta 5 voltios. Aquí, una o dos líneas de código son suficientes y el voltaje se aplica directamente al pin A0:
valor int = analogRead(0); // leer lecturas de A0
voltaje = (valor / 1023.0) * 5; // verdadero sólo si Vcc = 5,0 voltios
Segundo caso: para medir voltajes superiores a 5 voltios se utiliza un divisor de voltaje. El circuito es muy simple, al igual que el código.
Bosquejo
int entrada analógica = A0;
valor flotante = 0,0;
voltaje de flotación = 0,0;
flotador R1 = 100000,0; //Vin de la batería-> 100K -> A0
flotador R2 = 10000,0; //Tierra de la batería -> Tierra de Arduino y Tierra de Arduino -> 10K -> A0
valor entero = 0;
Configuración nula() (
Serie.begin(9600);
pinMode(entrada analógica, ENTRADA);
}
Bucle vacío() (
valor = lectura analógica (entrada analógica);
valor = (valor * 4,7) / 1024,0;
voltaje = valor / (R2/(R1+R2));
Serial.println(voltaje);
retraso(500);
}
ArduinoUno
módulo bluetooth
Tercer caso. Cuando necesites obtener información más precisa sobre el voltaje, debes utilizar como voltaje de referencia no el voltaje de alimentación, que puede variar ligeramente cuando se alimenta con una batería, por ejemplo, sino el voltaje del estabilizador interno de Arduino de 1,1 voltios. El circuito es el mismo aquí, pero el código es un poco más largo. No analizaré esta opción en detalle, ya que ya está bien descrita en artículos temáticos, pero el segundo método me basta, ya que mi fuente de alimentación es estable, desde el puerto USB del portátil.
Ahora que hemos resuelto la medición de voltaje, pasemos ahora a la segunda mitad del proyecto: crear una aplicación para Android. Crearemos la aplicación directamente desde el navegador en un entorno de desarrollo visual. Aplicación de aplicaciones de Android Inventor 2. Vaya al sitio web appinventor.mit.edu/explore, inicie sesión con su cuenta de Google, haga clic en el botón crear nuevo proyecto y simplemente arrastrando y soltando elementos creamos algo como este diseño:
Mantuve los gráficos muy simples si alguien quiere más. gráficos interesantes, déjame recordarte que para esto necesitas usar archivos .png con un fondo transparente en lugar de archivos .jpeg.
Ahora vaya a la pestaña Bloques y cree la lógica de la aplicación allí, algo como esto:
Si todo funciona, puede hacer clic en el botón Crear y guardar el .apk en mi computadora, y luego descargar e instalar la aplicación en su teléfono inteligente, aunque existen otras formas de cargar la aplicación. aquí es más conveniente para cualquiera. Como resultado, terminé con esta aplicación:
Entiendo que pocas personas utilizan el entorno de desarrollo visual App Inventor 2 para aplicaciones de Android en sus proyectos, por lo que pueden surgir muchas dudas sobre cómo trabajar en él. Para eliminar algunas de estas preguntas, hice vídeo detallado, sobre cómo crear una aplicación de este tipo “desde cero” (para verla debes ir a YouTube):
PD Una colección de más de 100 materiales educativos sobre Arduino para principiantes y profesionales.
