Tabla de contenido:
- Suministros:
- Paso 1: Lo que necesitará: Lista de piezas
- Paso 2: PRINCIPIOS BÁSICOS DVM
- Paso 3: Construcción del circuito
- Paso 4: CÓDIGO DVM de 2 canales
- Paso 5: Calibración
- Paso 6: Muestreo, promediado y visualización
- Paso 7: Los Programas en Programable.
- Paso 8: Video de DVM Programable
Este Instructable le enseñará cómo usar los puertos analógicos de Arduino.
Los voltímetros digitales (DVM) son un caso especial de convertidores de analógico a digital (A / DC, por sus siglas en inglés); miden el voltaje, y generalmente son una función de un instrumento de propósito general denominado multímetro digital (DMM, por sus siglas en inglés), comúnmente utilizado para medir voltajes en laboratorios y en el campo. Los DMM muestran el voltaje medido utilizando LCD o LED para mostrar el resultado en un formato de punto flotante. Son un instrumento de elección para mediciones de voltaje en todo tipo de situaciones. Este instructivo le mostrará cómo usar el Arduino como DC DVM (voltímetro digital de corriente directa).
Utilizaremos las entradas analógicas de Arduino para medir voltajes de CC entre 0 y 5 V y mostraremos los valores en una pantalla TFT LCD a color.
Utilicé el Sainsmart Arduino Nano y el Arduino UNO R3 oficial para ver si hay alguna diferencia.
Los rangos de voltaje que el Arduino puede medir se pueden expandir fácilmente usando dos resistencias para crear un divisor de voltaje.
El divisor de voltaje reduce literalmente el voltaje que se mide, por lo que está dentro del rango de las entradas analógicas de Arduino (es decir, de 0 a 5 voltios).
Luego, puede programar el croquis de Arduino para calcular los voltajes reales que se miden multiplicando la entrada por el factor de escala.
Esto nos permitirá medir voltajes superiores a 5 VCC, el voltaje máximo de CC que podemos medir de manera segura es de ~ 50 VCC con las partes utilizadas en este instructivo, pero puede modificarse para satisfacer sus necesidades.
Suministros:
Paso 1: Lo que necesitará: Lista de piezas
El costo total es de alrededor de $ 35 dolares!
- Un Arduino (usé el Sainsmart Nano Clone, ($ 13.99) y un UNO R3, pero creo que cualquiera lo hará)
- Una PC con el IDE arduino y un puerto USB libre.
- Un cable USB para tu Arduino.
- A Sainsmart 1.8 "TFT COLOR LCD ($ 12.99) Pantalla
- 4 x 1 Mega Ohm Resistors (Brown, Black, Green) 1 para cada canal
- 4 x 100 Kilo Ohm Resistors (Marrón, Negro, Amarillo) 1 para cada canal
- 4 diodos zener de 5,1 voltios (opcional |) para una mayor protección de las entradas analógicas Arduino
- Cables de puente, muchos de ellos, diferentes tamaños y colores.
- Tabla de soldadura sin soldadura (Estoy usando. Mi radioShack electronic experimenters lab breadboard)
- Un multímetro y / o referencia de voltaje para calibrar las salidas DVM
Paso 2: PRINCIPIOS BÁSICOS DVM
Antes de comenzar a armar el proyecto, revisemos algunos principios básicos y precauciones con respecto a las mediciones de voltaje con un DVM.
Exactitud y precisión
Nuestro DVM no será tan preciso ni exacto como una unidad disponible comercialmente, pero ciertamente será más flexible.
Para que las lecturas sean lo más precisas posible, debemos considerar dos cosas: la resolución de entrada y la calibración. La resolución de entrada depende del convertidor A / D de entrada analógica Arduinos, que es de 10 bits en Arduino uno y nano. La calibración dependerá de la calidad de los componentes utilizados y de las referencias utilizadas para calibrar las mediciones.
Impedancia de entrada
Los multímetros comerciales digitales que miden el voltaje de CC generalmente tendrán una impedancia de entrada muy alta de 10 MΩ o mayor (es decir, la resistencia entre las dos sondas de prueba multimétricas es de 10 MΩ o más).
Se necesita una alta impedancia de entrada para un voltímetro para que el voltímetro no afecte el valor del circuito que se está midiendo.
Si un voltímetro tiene una impedancia de entrada baja, es posible que pueda cambiar el voltaje que se está midiendo y darle lecturas incorrectas.
También hay un inconveniente, sin embargo, de tener una alta impedancia de entrada; Las sondas de prueba son más propensas a detectar interferencias electromagnéticas (EMI) que también pueden compensar sus mediciones y mostrar lecturas "fantasmas".
Aunque es deseable una alta impedancia de entrada, el circuito divisor de voltaje que usaremos le dará a nuestro voltímetro una impedancia de entrada de aproximadamente 1MΩ, que es aceptable para la mayoría de las mediciones de baja tensión y los circuitos de baja impedancia que generalmente construyen los aficionados a la electrónica.
Circuito divisor de voltaje
Usaremos dos resistencias en serie que reducirán el voltaje de entrada a un rango dentro de los límites seguros de las especificaciones de entrada analógica de Arduino. La ecuación básica del divisor de voltaje es:
V out = V in * R b / (R a + R b)
Si:
R a = 1MΩ
R b = 100KΩ
V out = 5V (la tensión máxima para los pines de entrada analógica de arduino)
entonces;
V in = 55V (la tensión máxima que puede medirse con seguridad)
El circuito que usaremos dividirá el voltaje de entrada por 11; (100K / (100K + 1M)) = (100/1100) = (1/11)
Restricción de terreno común
La mayoría de los DVMS comerciales le permiten medir el voltaje en cualquier componente, no solo desde una referencia a tierra. Nuestro voltímetro basado en Arduino no puede hacer eso, solo puede medir desde una referencia a tierra porque el pin Arduino GND se utiliza como el cable de sonda de prueba común o negativo (COM) de un multímetro estándar, y se debe conectar a la tierra del circuito bajo prueba.
Protección de entrada
Los valores de resistencia que estamos utilizando proporcionan cierta protección contra sobretensiones cuando se miden voltajes bajos y hasta alrededor de 55 voltios. Para proteger el Arduino de una sobretensión accidental (> 55VDC), podemos, opcionalmente, usar diodos zener de 5.1 voltios en paralelo con las resistencias de 100 KΩ. Esto proporcionará protección adicional a los pines de entrada analógica de Arduino.
Voltaje maximo
Como se explicó anteriormente, el punto en la red divisoria de resistencia conectada al pin de entrada analógica de Arduino es igual al voltaje de entrada dividido por 11 (55V ÷ 11 = 5V). El voltaje máximo que se puede medir de manera segura es de 55 voltios, el pin analógico Arduino estará a su voltaje máximo de 5V.¡¡¡Precaución!!! no intente medir voltajes superiores a 55 voltios o podría dañar su Arduino
Paso 3: Construcción del circuito
Comenzaremos construyendo un divisor de voltaje y conectándolo al Arduino, probaremos el circuito con un simple boceto y procederemos a construir el resto de los circuitos.
Una vez que tengamos las entradas funcionando, instalaremos la pantalla TFT LCD Color de 1.8 "y escribiremos un boceto para mostrar la medición de entrada en ella.
Luego exploraremos varias opciones de software y hardware para mejorar o personalizar el DVM.
Así que comencemos construyendo el divisor de voltaje en el tablero y conectándolo al pin A0 del Arduino.
Mire el diagrama del circuito y las otras imágenes para guiarlo con los pasos.
Una vez que se haya juntado el circuito, conecte el Arduino al puerto USB de su PC y cargue el siguiente boceto de prueba que mostrará el voltaje conectado a la pata de resistencia gratuita de 1Meg a través del monitor en serie.
Simplemente copie y pegue el siguiente boceto en el IDE de Arduino.
// ----------------- Sketch Start -----------------------------
/* -----------------------------------------------------------
Programa: SERIAL DVM
Descripción: voltímetro de CC con voltaje mostrado en el monitor serie
Sin color TFT LCD todavía!
Hardware: Arduino NANO o Uno con divisor de voltaje en A0.
Software: Escrito y Desarrollado usando el software Arduino 1.0.3
Fecha:
Autor:
--------------------------------------------------------------*/
// valores de calibración del divisor de voltaje
#define Dv1 11
// Tensión de referencia ADC / valor de calibración
#define VREF 5
flotador V1 = {0.00};
configuración del vacío ()
{
Serial.begin (9600);
}
bucle de vacío ()
{
V1 = analogRead (0);
Serial.print ("Voltage @ pin A0");
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
}
// ----------------- Sketch End -----------------------------
Repasemos lo que está pasando;
El controlador Atmega utilizado para el Arduino contiene un convertidor analógico a digital (A / D) de 6 canales incorporado. El convertidor tiene una resolución de 10 bits, que devuelve un número entero de 0 a 1023 (210= 1024, 0 cuentas, por lo que son 1023 pasos) para el valor de 0 a 5 voltios.
Queremos convertir el valor A / D devuelto al voltaje real que estamos midiendo.
Necesitamos multiplicar el resultado por 5 y dividir por 1023 para ajustar el valor devuelto por el convertidor A / D de 10 bits.
También estamos dividiendo el voltaje por 11 con el divisor de voltaje, por lo que el voltaje que estamos midiendo (y queremos ver en la pantalla), debe ser multiplicado por 11 para compensar la división.
Lo hacemos con la siguiente fórmula:
Vout = ((Vin * (5/1023)) * 11).
El código para esto es:
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
Multiplicamos por 5 (VREF) y dividimos por 1023 para convertir la salida A / D en una escala entre O y 5, luego multiplicamos por 11 (Dv1) para compensar el divisor de voltaje. La razón por la que estamos utilizando variables para los valores de divisor y voltaje, es que estos valores cambiarán cuando calibremos el DVM. El "2" al final de la fórmula define cuántos dígitos se mostrarán después del decimal.
Si tienes el programa para cargar correctamente, abre el monitor de serie haciendo clic en el icono de aumento en la esquina superior derecha del IDE de arduino, deberías ver los datos fluyendo. Usando un cable de puente, intente conectar la pata libre de la resistencia de 1Meg al Pin GND primero y luego al pin de 5V. Debería ver el cambio de lectura de 0 a 5v.
Ahora solo tenemos que repetir lo que hicimos para el primer canal tres veces más para tener un DVM de 4 canales, pero antes de hacerlo, conectemos nuestra PANTALLA LCD TFT COLOR al Arduino. Necesitará 7 cables de puente para hacer esto:
Conecta lo siguiente con los saltadores.
TFT LCD. Arduino
VCC 5V
GND Gnd
SCL 13
SDA 11
CS 10
RS / DC 9
RES 8
Nota:
A diferencia de mis otros instructables, utilizaremos la interfaz SPI de alta velocidad para controlar la pantalla, por lo que el cableado del puente es diferente. De nuevo, echa un vistazo a las imágenes para guiarte si no estás seguro de cómo conectarlo.
Necesitará instalar dos bibliotecas para usar la pantalla:
Adafruit_GFX.h La biblioteca de gráficos Core
Adafruit_ST7735.h La biblioteca específica del hardware
Descargue las bibliotecas y cópielas en la carpeta de la biblioteca Arduino.
Copie y pegue el siguiente boceto en el IDE de Arduino. El código DVM del bosquejo es el mismo, pero con la adición de un código para mostrar el voltaje en A0 en la pantalla LCD.
Compila y sube el boceto al Arduino.
// ----------------- Sketch Start -----------------------------
/*-----------------------------------------------------------
Programa: TFTLCDDVM
Descripción: voltímetro de corriente continua con tensión visualizada
en color TFT LCD a 2 decimales
Hardware: Arduino NANO con divisor de tensión en A0.
TFT LCD conectado
Software: Desarrollado usando el software Arduino 1.0.3
Fecha: 10 de marzo de 2014.
Autor: johnag
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Core graphics library
#include // biblioteca específica de hardware
#incluir
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// valor de calibración del divisor de voltaje
#define Dv1 11
// Tensión de referencia ADC
#define VREF 5
flotador V1 = {0.00};
configuración del vacío ()
{
Serial.begin (9600);
tft.initR (INITR_BLACKTAB); // inicializar un chip ST7735S, pestaña negra
tft.fillScreen (ST7735_BLACK); // pantalla clara
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("DC voltímetro DVM");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Caution max voltaje 55vdc");
}
bucle de vacío ()
{
V1 = analogRead (0);
tft.drawLine (0, 20, tft.width () - 1, 20, ST7735_WHITE);
tft.drawLine (0, 130, tft.width () - 1, 130, ST7735_WHITE);
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setTextSize (2);
// voltaje 1 (pin A0)
// la tensión se multiplica por la red de resistencias
// factor de división para calcular la tensión real
tft.setCursor (45, 40);
tft.println ("V1");
tft.setTextSize (1);
tft.println ("Voltage @ pin A0");
tft.setCursor (20, 80);
tft.setTextSize (2);
Serial.print ("Voltage @ pin A0");
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print (((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print ("Vdc");
}
// --------------- Sketch End ------------------------------- ---------
Paso 4: CÓDIGO DVM de 2 canales
A continuación se muestra el boceto de una copia DVM de 2 canales y se pega en el IDE de Arduino. Dejaré el código para el DVM de 4 canales para después de que se hizo con la calibración.
// --------------------------- 2channel DVM start ------------------ ---
/*--------------------------------------------------------------------
Programa: voltímetro_LCD
Descripción: voltímetro DC de 2 canales con voltajes mostrados
en color TFT LCD a 1 decimal
Hardware: Arduino NANO con divisores de tensión en A0 y A1
TFT LCD conectado
Software: Desarrollado usando el software Arduino 1.0.3
Fecha: 10 de marzo de 2014.
Autor:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Core graphics library
#include // biblioteca específica de hardware
#incluir
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// valores de calibración del divisor de voltaje
#define Dv1 11.00 // calculada midiendo el voltaje en la unión de la resistencia
#define Dv2 11.25
// Tensión de referencia ADC / valor de calibración
#define VREF 4.9
flotador V1 = {0.0};
flotador V2 = {0.0};
configuración del vacío ()
{
tft.initR (INITR_BLACKTAB); // inicializar un chip ST7735S, pestaña negra
tft.fillScreen (ST7735_BLACK); // pantalla clara
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println ("voltímetro de 2 canales");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Caution max voltaje 55vdc");
}
bucle de vacío ()
{
V1 = lectura analógica (A0);
V2 = lectura analógica (A1);
tft.drawLine (0, 20, tft.width () - 1, 20, ST7735_WHITE);
tft.drawLine (0, 130, tft.width () - 1, 130, ST7735_WHITE);
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
// voltaje 1 (pin A0)
tft.setCursor (5, 40);
tft.setTextSize (1);
tft.println ("Voltage @ pin A0");
tft.setTextSize (2);
tft.setCursor (10, 50);
tft.print ("V1");
tft.print (((((V1 * VREF) / 1023)) * Dv1, 1);
tft.print ("V");
// voltaje 2 (pin A1)
tft.setCursor (5, 70);
tft.setTextSize (1);
tft.println ("Voltage @ pin A1");
tft.setTextSize (2);
tft.setTextColor (ST7735_GREEN, ST7735_BLACK);
tft.setCursor (10, 80);
tft.print ("V2");
tft.print (((((V2 * VREF) / 1023)) * Dv2, 1);
tft.print ("V");
}
// --------------------------- 2channel DVM END ------------------
Paso 5: Calibración
Pasos para la calibración:
- Mida el voltaje en el pin de 5v en el Arduino con su multímetro, y use ese número en el código como el valor VREF. por ejemplo, si midió 5.0v, entonces la línea en el boceto que define VREF debería ser #define VREF 5.0.
- En su circuito divisor de voltaje, conecte la pata libre en la resistencia de 1 meg al pin 5v de su Arduino, y mida el voltaje en todo el divisor de tensión y luego el voltaje en la resistencia de 100 k. (Primero de GND a 5v, luego de GND al punto de unión de la resistencia, a través de la resistencia de 100k). Ahora divida los dos voltajes, por ejemplo, obtuve 5.0 para el voltaje de GND a 5v y 0.46v para el voltaje en la resistencia de 100k, así que divido 5 por 0.46: 5 / 0.46 = 10.869
- Coloque ese valor en la línea de definición Dv1: #define Dv1 10.869.
- Suba el boceto y vea si la lectura en su pantalla coincide con la lectura en su multímetro.
- Repita los pasos para todos los divisores de tensión y cambie los valores en consecuencia.
Paso 6: Muestreo, promediado y visualización
De acuerdo, calibramos el DVM, pero las lecturas aún parecen un poco inestables y ligeramente desviadas. Todavía hay algo que podemos hacer al respecto. En lugar de solo mostrar la entrada medida, ¿por qué no tomamos varias muestras, las sumamos y dividimos la suma por el número de muestras tomadas? Esto nos dará un promedio de los valores en la entrada y nos proporcionará una lectura más estable. Vamos a hacer eso usando el mientraslazo.
El siguiente boceto utiliza muestreo y promedios para mejorar los valores mostrados. Cópialo y pégalo en el IDE de Arduino y compílalo y cárgalo.
// ----------------- Sketch Start -----------------------------
/*--------------------------------------------------------------
Programa: DVM de 1 canal con muestreo.
Descripción: Lee el valor en la entrada analógica A0 y calcula
la tensión con un divisor de tensión
Red en el pin A0 que se divide por 10.195 y un voltaje de referencia de 5.0v.
Hardware: Arduinonano o Uno con divisor de voltaje en A0.
Software: Desarrollado usando el software Arduino 1.0.3
Debe ser compatible con Arduino 1.0 +
Fecha: 25 de marzo de 2014
Autor:
--------------------------------------------------------------*/
# defina NUMSAMP 100 // número de muestras a tomar antes de promediar y mostrar
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#define Dv1 10.915 // Valor del divisor de voltaje
#define VREF 5.0 // Voltaje medido @Arduino 5V pin
#include // Core graphics library
#include // biblioteca específica de hardware
#incluir
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int suma = 0; // Suma de muestras tomadas
Scount sin signo = 0; // Número de muestra actual
flotador AVvolts = 0.0; // Tensión media calculada
configuración del vacío ()
{// Configurar mostrar e imprimir elementos estáticos
tft.initR (INITR_BLACKTAB); // inicializar un chip ST7735S, pestaña negra
tft.fillScreen (ST7735_BLACK); // pantalla clara
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("DC voltímetro DVM");
tft.println ("");
tft.println ("");
tft.print ("Voltage @ pin A0");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Caution max voltaje 55vdc");
}
bucle de vacío ()
{
// tomar una serie de muestras analógicas y sumarlas
while (Scount <NUMSAMP) {
suma + = analogRead (A0); // leer y agregar las muestras
Scount ++; // incrementa el conteo de la muestra
retraso (10); // Espere 10 ms antes de leer la siguiente muestra
}
AVvolts = ((float) sum / (float) NUMSAMP * VREF) / 1023; // calcular el voltaje promedio
// Mostrar el voltaje promedio calculado
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setTextSize (2);
tft.setCursor (45, 50);
tft.println ("V1");
tft.setCursor (10, 80);
tft.setTextSize (2);
tft.print (AVvolts * Dv1);
tft.println ("Vdc");
Scount = 0;
suma = 0;
}
// ----------------- Sketch End -----------------------------
Paso 7: Los Programas en Programable.
Hay 10 tipos de personas, las que saben binario y las que no.
Hasta ahora, hemos aprendido cómo armar un Arduino y agregar divisores de voltaje para condicionar la señal de entrada analógica (voltaje) al reducir la señal a un nivel que está dentro de los parámetros de las especificaciones de Arduino. Luego compilamos y subimos algunos bocetos que leen las señales y los mostramos en el monitor serie y en la pantalla LCD TFT. Ahora depende de usted estudiar el código y continuar el trabajo. Incluyo el código para los bocetos de oter que se ejecutarán con el hardware que armamos juntos.
/*--------------------------------------------------------------
Programa: DVM de 1 canal con muestreo.
Descripción: Lee el valor en la entrada analógica A0 y calcula el voltaje asumiendo
hay un divisor de voltaje en el pin A0 que se divide por 10.195
Hardware: Arduino NANO o UNO con divisor de voltaje en A0.
Software: Escrito usando Arduino 1.0.3 IDE
Fecha: 25 de marzo de 2014
Autor:
--------------------------------------------------------------*/
// número de muestras analógicas a tomar por lectura
#define NSAMP 100
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Core graphics library
#include // biblioteca específica de hardware
#incluir
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int suma = 0; // suma de muestras tomadas
Scount sin signo = 0; // número de muestra actual
flotador V1 = 0.00; // Voltaje promedio calculado
flotador VMAX = 0,00;
flotar VMIN = 100.00;
valor flotante = 0,00;
flotador VREF = 5.0;
flotador Dv1 = 10.935;
configuración del vacío ()
{
tft.initR (INITR_BLACKTAB); // inicializar un chip ST7735S, pestaña negra
tft.fillScreen (ST7735_BLACK); // pantalla clara
tft.setTextColor (ST7735_GREEN);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("DC voltímetro DVM");
tft.setTextColor (ST7735_WHITE);
tft.println ("Voltage @ pin A0");
tft.print ("Con valores MAX, MIN");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Caution max voltaje 55vdc");
}
bucle de vacío ()
{
// tomar una serie de muestras analógicas y sumarlas
while (Scount <NSAMP) {
sum + = analogRead (A0); // lee y agrega las muestras
val = (analogRead (A0)); // almacenamiento temporal para MAX / MIN
tft.setCursor (45, 110);
tft.println (val);
if (val> VMAX) {// obtiene el valor MAX de la muestra
(VMAX = val);
}
if (val <VMIN) {// obtiene el valor MIN de la muestra
(VMIN = val);
}
Scount ++; // incrementa el conteo de la muestra
retraso (10); // Espere 10 ms antes de leer la siguiente muestra
}
// Una vez hecho el muestreo, calcular y mostrar el voltaje promedio calculado
V1 = ((float) suma / (float) NSAMP * VREF * Dv1) / 1024.0;
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setCursor (45, 40);
tft.setTextSize (2);
tft.println ("V1");
tft.setCursor (10, 60);
tft.print (V1);
tft.println ("Vdc");
tft.setCursor (20, 90);
tft.setTextSize (1);
tft.setTextColor (0xff00, ST7735_BLACK);
tft.print ("VMAX");
tft.print ((float) VMAX * VREF / 1023 * Dv1); // calcula y muestra la tensión máxima calculada
tft.println ("Vdc");
tft.setCursor (20, 100);
tft.setTextColor (ST7735_GREEN, ST7735_BLACK);
tft.print ("VMIN");
tft.print ((float) VMIN * VREF / 1023 * Dv1); // calcula y muestra la tensión mínima calculada
tft.print ("Vdc");
Scount = 0; // restablecer el recuento de muestras
suma = 0; // restablecer la suma
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*--------------------------------------------------------------
Programa: voltímetro de 4 canales voltímetro
Descripción: voltímetro DC de 4 canales con voltajes mostrados
en color TFT LCD a 1 decimal, usando muestreo y promediando
Hardware: Arduino NANO o UNO con divisores de voltaje en A0 a A3.
TFT LCD conectado
Software: Desarrollado usando el software Arduino 1.0.3
Fecha: 10 de marzo de 2014.
Autor:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Core graphics library
#include // biblioteca específica de hardware
#incluir
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// número de muestras analógicas a tomar por lectura, por canal
# defina NSAMP 100 // número de muestras para mostrar antes
// valores de calibración del divisor de voltaje
#define Dv1 11.00
#define Dv2 11.001
#define Dv3 11.00
#define Dv4 10.985
// Tensión de referencia ADC / valor de calibración
#define VREF 5.00
int suma 4 = {0}; // sumas de muestras tomadas
Scount sin signo = 0; // número de muestra actual
flotante AVvolts 4 = {0.0}; // voltajes calculados
char cnt1 = 0; // usado en bucles 'for'
configuración del vacío ()
{
tft.initR (INITR_BLACKTAB); // inicializar un chip ST7735S, pestaña negra
tft.fillScreen (ST7735_BLACK); // pantalla clara
tft.setTextColor (ST7735_WHITE);
tft.drawRoundRect (2, 20, 120, 110, 5, ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println ("voltímetro de 4 canales");
tft.setTextColor (0XFF00);
tft.setCursor (0,140);
tft.println ("Caution max voltaje 55vdc");
}
bucle de vacío ()
{
// tomar una serie de muestras analógicas y sumarlas
while (Scount <NSAMP) {
// muestra cada canal A0 a A3
para (cnt1 = 0; cnt1 <4; cnt1 ++) {
suma cnt1 + = analogRead (A0 + cnt1);
}
Scount ++;
retraso (10);
}
// calcula la tensión para cada canal
para (cnt1 = 0; cnt1 <4; cnt1 ++) {
AVvolts cnt1 = ((float) sum cnt1 / (float) NSAMP * VREF) / 1024.0;
}
// mostrar los voltajes en TFT LCC Display
// tensión 1 - V1 (pin A0
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK); // establecer el color para V1
tft.setTextSize (2);
tft.setCursor (15, 40);
tft.print ("V1");
tft.print (AVvolts 0 * Dv1, 1);
tft.print ("V");
// voltaje 2 - V2 (pin A1)
tft.setTextColor (ST7735_GREEN, ST7735_BLACK); // configurar el color para V2
tft.setCursor (15, 60);
tft.print ("V2");
tft.print (AVvolts 1 * Dv2, 1);
tft.print ("V");
// voltge 3 - V3 (pin A2)
tft.setTextColor (ST7735_CYAN, ST7735_BLACK); // configurar el color para V3
tft.setCursor (15, 80);
tft.print ("V3");
tft.print (AVvolts 2 * Dv3, 1);
tft.print ("V");
// voltaje 4 - V4 (pin A3)
tft.setTextColor (ST7735_WHITE, ST7735_BLACK); // configurar el color para V4
tft.setCursor (15, 100);
tft.print ("V4");
tft.print (AVvolts 3 * Dv4, 2);
tft.print ("V");
tft.drawRoundRect (2, 20, 120, 110, 5, ST7735_WHITE);
// restablecer el recuento y las sumas
Scount = 0;
para (cnt1 = 0; cnt1 <4; cnt1 ++) {
suma cnt1 = 0;
}
}