Se debe diseñar un voltimétro digital con cuatro cifras significativas, mediante el uso de un microcontrolador (PIC ó Arduino). El Voltimétro debe leer niveles de voltajes de 0 a 5 voltios. La medida de voltaje se debe visualizar en un pantalla LCD conectada al micro controlador.
Carrera: Ingeniería de Telecomunicaciones
ResponderEliminarElaborado por:
Reyes Romelia C.I.: 22352681
Delgado Rubí C.I.: 19266205
Laboratorio de Microprocesadores practica #3
Diseñar un voltímetro digital que mida con una precisión de 4 dígitos un nivel de voltaje entre 0 y 5v.
Para la elaboración de este proyecto realizamos nuestro programa en Pic-C, tomando en cuenta que debemos utilizar un conversor analógico digital ubicado en el puerto A del pic18F4550 para mostrar en nuestra pantalla LCD un valor de 4 dígitos los cuales van a variar al mover el potenciómetro, para eso debemos establecer ciertas condiciones en el programa. Continuamente lo simulamos en proteus para verificar si se ejecutara bien el programa y posteriormente lo montamos en el protoboard para ser presentado.
Los materiales para el montaje en el protoboard son:
1 Pantalla LCD 16x2
1 Pic 18F4550
1 Cristal de 20MHz
2 Condensadores de 22pF
1 Resistencia de 330ohmios
2 Dos potenciómetros de 10K
A continuación se anexa el código del programa del voltímetro
#include <18f4550.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOPUT
#device adc=10
#use delay(clock=20000000)
int16 valor_digital;
float voltaje;
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include
void main()
{
lcd_init();
setup_adc_ports(AN0);
convercion adc del puerto (ano).
setup_adc(ADC_CLOCK_INTERNAL
while(true)
{
set_adc_channel(0);
delay_us(800);
valor_digital=read_adc();
voltaje=5.0*valor_digital/1024.0;
printf(lcd_putc,"\f PROYECTO No 3");
lcd_gotoxy(1,2);
printf(lcd_putc, "V= %1.3f volts",voltaje);
delay_ms(650);
}
}
Profesor: Ing. José Muñoz
ResponderEliminarCarrera: Ingeniería de Telecomunicaciones
Elaborado por: Rubén Delgado CI 19266207
Yarotxy Ortiz CI 20294405
Laboratorio de microprocesadores •#3
Diseñar de un voltímetro digital con cuatro cifras significativas, mediante el uso de un microcontrolador PIC . El Voltimétro debe leer niveles de voltajes de 0 a 5 voltios. La medida de voltaje se debe visualizar en un pantalla LCD conectada al micro controlador
Para realizar este proyecto lo primero que debemos de tomar en cuenta es que tenemos que realizar la parte lógica de la siguiente manera: establecer nuestras condiciones bajo diversos comandos de la programación en nuestro compilador PIC-C y luego simularlo en proteus para tener una idea más clara de lo que será nuestro proyecto en la realidad, una vez alcanzado este proceso con nuestros materiales procedemos a ejecutar nuestro programa codificado y simulado en proteus en nuestro protoboard, para así ver nuestro funcionamiento de manera efectiva si ningún error.
Materiales:
Protoboard
PIC-C 18f4550
Pantalla lcd 2x16
1 cristal de 20.000 Mhz
1 resistencias de 330
Cable para protoboard
2 condensadores de 22pf
1 fuente de 5v
2 Potenciómetro de 10kohm
Tomaremos en consideración el datasheet de nuestra pantalla 2x16 y de nuestro pic 18f4550 para obtener una información solida de cómo es y así poder realizar las conexiones de manera efectiva y tener un montaje en nuestro protoboard positivo sin error, así lograremos ver en nuestra pantalla el mensaje que venimos trabajando por medio de nuestra codificación.
Consideración lógica “Codigo”.
#include <18f4550.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOPUT
#device adc=10
#use delay(clock=20000000)
int16 valor_digital;
float voltaje;
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include
void main()
{
lcd_init();
setup_adc_ports(AN0);
convercion adc del puerto (ano).
setup_adc(ADC_CLOCK_INTERNAL
while(true)
{
set_adc_channel(0);
delay_us(800);
valor_digital=read_adc();
voltaje=5.0*valor_digital/1024.0;
printf(lcd_putc,"\f PROYECTO No 3");
lcd_gotoxy(1,2);
printf(lcd_putc, "V= %1.3f volts",voltaje);
delay_ms(650);
}
}
#MICROPROCESADORES
ResponderEliminarINTEGRANTES DE LABORATORIO
#Emir Davila c.i : 20.330.849
#Rosanna zacarias c.i:20.506.085
Objetivo General :Diseñar un voltimétro digital con cuatro cifras significativas, mediante el uso de un microcontrolador (PIC ó Arduino). El Voltimétro debe leer niveles de voltajes de 0 a 5 voltios. La medida de voltaje se debe visualizar en un pantalla LCD conectada al micro controlador.
Desarrollo Teórico - Practico :voltimetro es aquel instrumento de medida cuyo fin es medir o calcular el voltaje, el lenguaje que se utilizo es el C, compilado con Pic c y simulado en PROTEUS. en las siguiente lineas, explicaremos el código del programa, reordando que despues de un // todo lo que sigue es un comentario que el compilador ignora tomando en cuenta que explicamos sus lineas y lo que se desea realizar .
#include <18f4550.h> // directiva hace que el compilador incluya en nuestro fichero
#device ADC=8 // configuración deldispositivo, nos permite especificar el número de bits
#fuses HS,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv2,vregen // Directiva define que fusibles deben activarse en el dispositivo cuando se programe
#use delay(clock=4.8M) // directiva siempre que queramos usar las funciones que incorpora la librería de C para gener retardos
#int_AD // etiqueta de interrupcion
//#USE RS232 (BAUD=1200, BITS=8, XMIT=PIN_C6, RCV=PIN_C7)
#include
#include
#byte port_A=0XF80 // declaramos los puertos en su localidad
#byte port_B=0XF81
#byte port_C=0XF82
#byte port_D=0XF83
// variables
int8 conversion; // variable de conversion
void main()
{
float temp,conversion;// valor temporal
lcd_init(); //
lcd_putc("Cargando."); //Visualiza el carácter c en la siguiente posición del LCD.
delay_ms(200); // use delay especificando la frecuencia del reloj
lcd_putc("\f");
lcd_putc("Cargando..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando...");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando ..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando .");
delay_ms(200);
lcd_putc("\f");
SET_TRIS_a(0b00000001); //leer puerto A
setup_adc_ports(AN0_TO_AN4|vss_vdd);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(global); //control en el programa principal para permitiro no que se atienda la interrupción , Lo que va dentro del paréntesis en cada una de ellas, es el tipo de interrupción que manejamos
while(true) //permite ejecutar una o mas sentencias en tanto se cumpla una condición.
{
set_adc_channel(0); // comando para definir cuando el va a realizar la interrupcion
delay_us(10);
set_adc_channel(0); // el canal que queremos leer en este caso lo retenemos por segunda vez
delay_us(10);
conversion= read_adc();// este es el comando de conversion en el cual se toma el valor medido y lo convierte en el void voltimetro
temp = (conversion*196)/10000;
lcd_init();
lcd_gotoxy(1,1);// posición de la pantalla
printf(LCD_PUTC,"Volt:= %0.5fv",temp);
delay_ms(3000);
}
}
#MICROPROCESADORES
ResponderEliminarINTEGRANTES DE LABORATORIO
#Emir Davila c.i : 20.330.849
#Rosanna zacarias c.i:20.506.085
Objetivo General :Diseñar un voltimétro digital con cuatro cifras significativas, mediante el uso de un microcontrolador (PIC ó Arduino). El Voltimétro debe leer niveles de voltajes de 0 a 5 voltios. La medida de voltaje se debe visualizar en un pantalla LCD conectada al micro controlador.
Desarrollo Teórico - Practico :voltimetro es aquel instrumento de medida cuyo fin es medir o calcular el voltaje, el lenguaje que se utilizo es el C, compilado con Pic c y simulado en PROTEUS. en las siguiente lineas, explicaremos el código del programa, reordando que despues de un // todo lo que sigue es un comentario que el compilador ignora tomando en cuenta que explicamos sus lineas y lo que se desea realizar .
#include <18f4550.h> // directiva hace que el compilador incluya en nuestro fichero
#device ADC=8 // configuración deldispositivo, nos permite especificar el número de bits
#fuses HS,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv2,vregen // Directiva define que fusibles deben activarse en el dispositivo cuando se programe
#use delay(clock=4.8M) // directiva siempre que queramos usar las funciones que incorpora la librería de C para gener retardos
#int_AD // etiqueta de interrupcion
//#USE RS232 (BAUD=1200, BITS=8, XMIT=PIN_C6, RCV=PIN_C7)
#include
#include
#byte port_A=0XF80 // declaramos los puertos en su localidad
#byte port_B=0XF81
#byte port_C=0XF82
#byte port_D=0XF83
// variables
int8 conversion; // variable de conversion
void main()
{
float temp,conversion;// valor temporal
lcd_init(); //
lcd_putc("Cargando."); //Visualiza el carácter c en la siguiente posición del LCD.
delay_ms(200); // use delay especificando la frecuencia del reloj
lcd_putc("\f");
lcd_putc("Cargando..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando...");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando ..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando .");
delay_ms(200);
lcd_putc("\f");
SET_TRIS_a(0b00000001); //leer puerto A
setup_adc_ports(AN0_TO_AN4|vss_vdd);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(global); //control en el programa principal para permitiro no que se atienda la interrupción , Lo que va dentro del paréntesis en cada una de ellas, es el tipo de interrupción que manejamos
while(true) //permite ejecutar una o mas sentencias en tanto se cumpla una condición.
{
set_adc_channel(0); // comando para definir cuando el va a realizar la interrupcion
delay_us(10);
set_adc_channel(0); // el canal que queremos leer en este caso lo retenemos por segunda vez
delay_us(10);
conversion= read_adc();// este es el comando de conversion en el cual se toma el valor medido y lo convierte en el void voltimetro
temp = (conversion*196)/10000;
lcd_init();
lcd_gotoxy(1,1);// posición de la pantalla
printf(LCD_PUTC,"Volt:= %0.5fv",temp);
delay_ms(3000);
}
}
Este comentario ha sido eliminado por el autor.
ResponderEliminarEste comentario ha sido eliminado por el autor.
ResponderEliminarMICROPROCESADORES
ResponderEliminarPROFESOR: ING. JOSE MUÑOZ
KATHERINE FEBRES 19693437
IBRAHIM ZAMORA 21 232469
Materiales:
Protoboard
PIC-C 18f4550
Pantalla lcd 4x16
1 cristal de 4 Mhz
2 resistencia de 10k
Cable utp
2 condensadores de 22pf
1 fuente de 5v
#include <18f4550.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG, NOPUT
#use delay(clock=20000000)
#define adc=8;
int32 voltaje=0;
float valor=0.0;
#use fast_i0(a)
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include
//#INT_AD
//ad_isr(){
//set_adc_channel (0); /// habilita el AN0
//voltaje=Read_ADC(ADC_READ_ONLY); /// Leer pin analogico
// delay_ms(100); /// para evitar parpadeo
//valor=voltaje*5;
// valor=valor/256;
// printf(lcd_putc,"\fPROYECTO N 3\n");
// printf(lcd_putc,"Voltaje= %3.2f", valor); }
void main()
{
set_TRIS_A (0B00000001);
setup_adc_ports(AN0|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(INT_AD);
enable_interrupts(GLOBAL);
lcd_init();
while(true)
{
set_adc_channel(0); /// habilita el AN0
voltaje=Read_ADC(); /// Leer pin analogico
delay_ms(100); /// para evitar paradeo
valor=voltaje*5;
valor=valor/256;
printf(lcd_putc,"\fPROYECTO N 3\n");
printf(lcd_putc,"Voltaje= %3.3f", valor);
}
Procedimiento
Utilizamos 1 pic 18f4550 de la familia cmos, por lo tanto utilizaremos 5voltios, descargamos un data chip de del 18f4550 y así facilitar el procedimiento del montaje, construimos un programa con lenguaje c que se adaptara y cumpliera con los puntos o procedimientos de un voltímetro digital en el cual se refleje en un lcd, un patrón que contabilice visualmente la regulación de un voltaje por medio de un potenciómetro ya que por medio de este nos podremos aumentar el voltaje o disminuirlo. También conectamos cables UTP para poder conectar la pantalla con el pic, el potenciómetro, las resistencias, los puentes de que pasan corriente. También utilizamos un cargador de 5 voltios para suministrar la corriente de 5voltios.
Llamamos el pin 2 porque es donde vamos a leerla entrada, el pic lo vamos a utilizar como un puerto analógico en donde setup_adc_ports(ra0_analog); (convierte),declaramos la conversión analógica digital que estará en los caracteres (256) ,habilitamos la librería de la lcd ,un bucle donde la primera condición es donde se habilita el canal convertidor 0(an0),luego declaramos leer el pin analógico con voltaje=read_ADC declaramos un delay de 100 ms para poder verlo en en la pantalla ,también dijimos qu el valor =voltaje x5 y valor=valor/256 esto quiere decir que automáticamente se hará el cálculo. Terminando imprimimos lo que deseamos visualizar en la pantalla en la primera línea veremos proyecto #3 y en la siguiente línea el voltaje que será vista en decimal y de forma continua.
Integrantes: Raquel Jerez C.I:20789181
ResponderEliminarAngel Mijarez
Para la implementación de este proyecto se utilizaron varios comandos específicos para realizar el voltímetro. Este sistema de medida emplea técnicas de conversión analógico-digital con una precisión de 4 dígitos variando así el potenciómetro para obtener el valor numérico mostrado así en una pantalla numérica LCD el voltaje de 0 a 5 voltios. Para la creación del mismo se necesitara un conversor ADC. Los convertidores A/D son un dispositivo electrónico capaz de convertir una entrada analógica de voltaje en un valor binario, la señal analógica, que varía de forma continua en el tiempo, obteniéndose así una señal digital a la salida del mismo.
5Voltios
RA0
5V
Algunos comandos son
Device ADC=8: permite definir el pic con el que se realizara la compilación, bist para el ADC
Setup_adc (ADC_CLOCK): selecciona el reloj para el ADC
Set_adc_channel (0); es el canal que se utilizara en este caso es el canal 0
Valor_adc=read_adc (); lee el dato del canal
Materiales Utilizados
Pic 18f4550
Cristal
Dos condensadores de cerámica
Dos potenciómetros de 10kohm y 50 kohm
Protoboart
Pantalla LCD de 16x2
Ing Telecomunicaciones
ResponderEliminarMicroprocesadores
Profesor: Ing Jose Muñoz
Figueroa Edward 18530367
Rosales Wladimar 19582693
Materiales:
Protoboard
PIC-C 18f4550
Pantalla lcd 2x16
1 cristal de 20Mhz
1 resistencia de 10k
2 condensadores de 22pf
1 fuente de 5v
2 potenciómetros (5k y 100k)
El proyecto consta de la elaboración de un voltímetro digital el cual debe mostrar en la pantalla LCD el voltaje según movamos la perilla de uno de los potenciómetros, en este caso moveremos el de 5k.
El código implementado es el siguiente:
#include <18f4550.h>
#include
#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG, NOPUT
#use delay(clock=20M)
#define adc=8;
int32 volt;
float conv;
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
void main()
{
set_TRIS_A (0B00000001);
setup_adc_ports(AN0|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(INT_AD);
lcd_init();
while(true)
{
set_adc_channel(0);
volt=read_adc();
delay_ms(100);
conv=volt*5;
conv=conv/256;
printf(lcd_putc,"\f");
printf(lcd_putc,"Practica #3");
lcd_gotoxy(1,2);
printf(lcd_putc,"Volt: %3.2f", conv);
}
}
Ingeniería de Telecomunicaciones
ResponderEliminarMicroprocesadores
Profesor: Jose Muñoz
Zoraida Salazar
Amelis Leon
Proyecto # 3
Diseño de un voltimetro digital mediante el uso de microcontroladores
Para la elaboración de este proyecto primero se hizo el codigo en Pic C, posteriormente se realizo la simulación en proteus para verificar el funcionamiento y por ultimo hizo el montaje en proto board.
El funcionamiento de este proyecto consiste en variar el voltaje mediante el uso de un potenciometro ubicado en en pin A0.
Los materiales utilizados fueron los siguientes:
- Potenciometro
- Pantalla LCD de 16x4
- PIC 18f4550
- Resistencia
- Condensadores de 22pf
-Cristal de 20 Mhz
- protoboard
-Programa PIC C
- Simulador Proteus
La estructura del programa es la siguiente:
#include <18f4550.h>
#device ADC=8 ( Conversor analógico a digital)
#fuses HS,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv2,vregen
#use delay(clock=20M)
#int_AD (Etiqueta de interrupción)
//#USE RS232 (BAUD=1200, BITS=8, XMIT=PIN_C6, RCV=PIN_C7)
#include
#include
#byte port_A=0XF80 ( Se declaran los puertos en su localidad)
#byte port_B=0XF81
#byte port_C=0XF82
#byte port_D=0XF83
int8 conversion; (Variable de conversión)
void main()
{
float temp,conversion; (Valor temporal)
lcd_init();
lcd_putc(" Voltimetro");
lcd_gotoxy(1,3);
lcd_putc(" convertidor A/D");
delay_ms(1000);
lcd_putc("\f");
SET_TRIS_a(0b00000001);
setup_adc_ports(AN0_TO_AN4|vss_vdd);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(global);
while(true)
{
set_adc_channel(0); (comando para definir cuando el va a realizar la interrupción)
delay_us(10);
set_adc_channel(0);
delay_us(10);
conversion= read_adc(); ( este es el comando de conversion en el cual se toma el valor medido y lo convierte en el void voltimetro)
temp = (conversion*196)/10000;
lcd_gotoxy(1,1);
lcd_putc(" Proyecto #3");
lcd_gotoxy(1,3);
printf(LCD_PUTC," V= %f voltios",temp);
}
}
Adrian lopez C.I 19788631 Gina Guevara C.I 19965159
ResponderEliminarVoltímetro
#include <18f4550.h> #device ADC=8 //#fuses HS,nowdt,noprotect,nolvp,nodebug,usbdiv,pll 5,cpudiv2,vregen #use delay(clock=4.8M) #int_AD // etiqueta de interrupcion //#USE RS232 (BAUD=1200, BITS=8, XMIT=PIN_C6, RCV=PIN_C7) #include #include #byte port_A=0XF80 // declaramos el puerto a en su localidad #byte port_B=0XF81 #byte port_C=0XF82 #byte port_D=0XF83 // variables int8 conversion; // variable de conversion void main() { float temp,conversion;// valor temporal lcd_init(); lcd_putc("lectura de\n tension en LCD"); delay_ms(1000); lcd_putc("\f"); SET_TRIS_a(0b00000001); setup_adc_ports(AN0_TO_AN4|vss_vdd); setup_adc(ADC_CLOCK_DIV_8); enable_interrupts(global); while(true) { set_adc_channel(0); // comando para definir cuando el va a realizar la interrupcion delay_us(10); set_adc_channel(0); // en este caso lo retenemos por segunda vez delay_us(10); conversion= read_adc();// este es el comando de conversion en el cual se toma el valor medido y lo convierte en el void voltimetro temp = (conversion*196)/10000; lcd_init(); lcd_gotoxy(1,1); printf(LCD_PUTC,"tension= %fv",temp); } }
Ing. de Telecomunicaciones
ResponderEliminarMicroprocesadores 6D01
Integrantes:
José L. Sánchez G. C.I: 20307845
Jonathan Santos. C.I.: 19228876
PROYECTO N° 3
Voltímetro Digital con Muestra de 4 Dígitos
Es un voltímetro digital simple, que puede medir con seguridad voltajes de CC de entrada en rango de 0 a 30V. La placa Arduino puede ser alimentado por una batería de 9V estándar, como de costumbre.
Como bien sabe, las entradas analógicas de Arduino se pueden utilizar para medir el voltaje DC entre 0 y 5V (cuando se utiliza la tensión de referencia analógica estándar 5V) y este rango se puede aumentar mediante el uso de dos resistencias para crear un divisor de tensión. El divisor de tensión disminuye la tensión medida a ser dentro del rango de las entradas analógicas de Arduino. Código en el boceto Arduino se utiliza entonces para calcular la tensión real que se está midiendo.
El sensor analógico de la placa Arduino detecta el voltaje en el pin analógico y la convierte en un formato digital que puede ser procesada por el microcontrolador. Aquí, estamos alimentando la tensión de entrada a la clavija analógica (A0) utilizando un circuito divisor de tensión que comprende las resistencias R1 sencilla (100K) y R2 (10K) . Con los valores utilizados en el divisor de tensión es posible alimentar la tensión de 0V a 55V en la placa Arduino. La unión en la red de divisor de tensión conectado a la clavija de la analógica Arduino es equivalente a la tensión de entrada dividido por 11 , por lo 55V ÷ 11 = 5V . En otras palabras, cuando se miden 55V, el pasador analógica Arduino estará en su máximo voltaje de 5V. Así, en la práctica, es mejor para etiquetar este voltímetro como " 0-30V DVM " para añadir un margen de seguridad
Notas
Si la lectura de la pantalla no coincide cuando se compara con su DVM laboratorio, utilice un multímetro digital de precisión para encontrar la resistencia real de R1 y R2 , y reemplazar R1 = 100,000.0 y R2 = 10000.0 en el código con el que los valores . Siguiente compruebe la alimentación de 5V con el DVM laboratorio en los pines GND y 5V de la placa Arduino . Podría darle menos (por ejemplo 4.95V) , sustituya el valor en el código Vout = (valor * 5.0 ) / 1024.0 (es decir, reemplazar el valor de 5,0 V a la lectura real , en este caso 4.95V ) . Además, siempre trato de usar precisión resistencias del 1% de tolerancia para R1 y R2.
Los valores de las resistencias ( R1 y R2 ) en el diagrama del circuito proporcionan cierta protección contra sobretensión luego medir voltajes bajos . Mantenga en mente que cualquier tensión de entrada superior a aproximadamente 55V podría freír el Arduino. Ninguna otra protección (por picos de tensión, tensiones inversas o voltajes superiores) se incorpora en este circuito.
Componentes
Arduino Uno
100K Resistencia
10K Resistencia
100R Resistencia
10K Potenciómetro
16×2 Pantalla LCD
Código de programación
/*
Voltimetro DC
*/
#include
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
int analogInput = 0;
float vout = 0.0;
float vin = 0.0;
float R1 = 100000.0; // resistencia de R1 (100K)
float R2 = 10000.0; // Resistencia of R2 (10K)
int value = 0;
void setup(){
pinMode(analogInput, INPUT);
lcd.begin(16, 2);
lcd.setCursor(1, 0);
lcd.print("VOLTIMETRO DC");
}
void loop(){
// leer el valor de la entrada analógica
value = analogRead(analogInput);
vout = (value * 5.0) / 1024.0; // ver texto
vin = vout / (R2/(R1+R2));
if (vin<0.09) {
vin=0.0;//
}
lcd.setCursor(1, 1);
lcd.print("INPUT V= ");
lcd.print(vin);
delay(500);
}
Ingeniería en Telecomunicaciones
ResponderEliminarMicroprocesadores
6ITTC D-01
Profesor:
Ing. José Muñoz
Integrantes:
Jesús Urbina C.I: 19.581.133
Cristians Pérez C.I: 19.582.685
Resumen Practica 3
El siguiente proyecto es realizado con la finalidad de mostrar en una pantalla lcd de 16x2 la medicion de voltaje en la entrada anologica/digital del pic 18f4550 , además de mostrar en la primera linea de la misma un título fijo el cual será: PROYECTO # 3.
Para esto realizamos en el proteus la simulación del circuito compuesto por el pic 18f4550, un cristal de cuarzo de 4MHz, 2 condensadores de 22pf, 2 potenciómetros de 10k y una pantalla lcd de 16x2 todo esto conectado al pic, luego con el código respectivo se procede con la simulación. Luego de la simulación procedemos a la realización del montaje.
Materiales Utilizados:
Hardware:
- 1 Proto Board
- 1 PIC 18f4550
- 1 Pantalla Lcd 16x2
- 2 Potenciómetro de 10k
- 2 condensadores de 22pf
- 1 Cristal de Cuarzo de 20 MHz
- Cables UTP
- 1 Laptop
- 1 Programador de Pic
- 1 Fuente de 5v
Software:
- Proteus 8 Professional
- PIC C Compiler
- PICkit
Código:
#include <18F4550.h>
#device ADC=10
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=4M)
#include
#include
#byte port_A=0XF80
#byte port_B=0XF81
#byte port_C=0XF82
#byte port_D=0XF83
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
void main()
{
int16 q;
int16 z;
float p;
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
lcd_init();
for (;;)
{
set_adc_channel(0);
delay_us(20);
q = read_adc();
z = 5 * q;
p = z/1024.0;
lcd_gotoxy(1,1);
printf(lcd_putc,"%s","Proyecto #3");
lcd_gotoxy(1,2);
printf(lcd_putc, "Voltaje = %01.2fV", p);
delay_ms(100);
}
}
Ing. De telecomunicaciones
ResponderEliminarAlmnos: Maria Castaño C.I 22287611, Emely Reinosa C.I 20563860
Microprocesadores
POTENCIOMETRO
En este proyecto se realizo un medidor de voltaje que llegara hasta 5V, en la pantalla se muestra un entero con dos decimales (4.09V). Para poder generar rsto en la pantalla primero hicimos el programa y el simulador en el proteus lo corrimos y verificamos que mostrara en la pantalla el voltaje y poder variar el voltaje.En el PIC-C utilizamos el puerto B, utilizamos dos potenciometros uno para el contraste de la pantalla y otro para variar el voltaje.
Materiales:
2 Potenciometros
1 Resistencias
2 Condensadores
Pantalla lcd
pic-c 18f4550
Cristal 4MHz
Código del programa:
#include <118f4550.h>
#fuses XT, NOWDT, NOPROTECT, NOLVP, NODEBUG, NOPUT
#device adc=8
#use delay(clock=4000000)
#define LCD_ENABLE_PIN PIN_BO
#define LCD_RS_PIN PIN_B1
#define LCD_RW_PIN PIN_B2
#define LCD_DATA4 PIN_B4
#define LCD_DATA5 PIN_B5
#define LCD_DATA6 PIN_B6
#define LCD_DATA7 PIN_B7
int8 lectura=0;
float volts=0;
#include
vid main ()
{
lcd_init ();
setup_adc_ports (AN0);
setup_adc(ADC_CLOCK_INTERNAL);
while (true)
{
set_adc_channel (0);
delay_us (20);
lectura=read_adc ();
volts=5.0*lectura/255.0;
pronto (lcd_putc, "\f proyecto 3 \nVolt=% 1.2fv", volts);
delay_ms (150);
}
}
INTEGRANTES:
ResponderEliminarWilly Luis Chiri C.I.08337983
Rosangel Padierna C.I. 19852549
Practica 3
#include <18f4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,PLL5,CPUDIV4,MCLR
#device ADC=8
#USE delay (clock=48MHz)
#include
#int_AD
unsigned int8 valor_adc;
float valor=196;
float voltios;
float resultado;
void VOLTIMETRO ();
void main ()
{
lcd_init();
set_tris_a(0b00000001);
setup_adc_ports(AN0|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(global);
while(true)
{
set_adc_channel(0);
delay_us(10);
valor_adc=read_adc();
voltimetro ();
}
#MICROPROCESADORES
ResponderEliminarINTEGRANTES DE LABORATORIO Practica N3 VOLTIMETRO
#Emir Davila c.i : 20.330.849
#Rosanna zacarias c.i:20.506.085
Objetivo General :Diseñar un voltimétro digital con cuatro cifras significativas, mediante el uso de un microcontrolador (PIC ó Arduino). El Voltimétro debe leer niveles de voltajes de 0 a 5 voltios. La medida de voltaje se debe visualizar en un pantalla LCD conectada al micro controlador.
Desarrollo Teórico - Practico :voltimetro es aquel instrumento de medida cuyo fin es medir o calcular el voltaje, el lenguaje que se utilizo es el C, compilado con Pic c y simulado en PROTEUS. en las siguiente lineas, explicaremos el código del programa, reordando que despues de un // todo lo que sigue es un comentario que el compilador ignora tomando en cuenta que explicamos sus lineas y lo que se desea realizar .
Materiales Necesarios : Para su montaje físico en Protoboard.
1 Pantalla LCD 16x4
1 Pic 18F4550
1 Cristal de 20MHz
2 Condensadores de 22pF
1 Resistencia de 330ohmios
2 Dos potenciómetros de 10K
CODIGO DEL PROGRAMA PARA OBTENER VOLTAJES HASTA = 5V
#include <18f4550.h> // directiva hace que el compilador incluya en nuestro fichero
#device ADC=8 // configuración deldispositivo, nos permite especificar el número de bits
#fuses HS,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv2,vregen // Directiva define que fusibles deben activarse en el dispositivo cuando se programe
#use delay(clock=4.8M) // directiva siempre que queramos usar las funciones que incorpora la librería de C para gener retardos
#int_AD // etiqueta de interrupcion
//#USE RS232 (BAUD=1200, BITS=8, XMIT=PIN_C6, RCV=PIN_C7)
#include
#include
#byte port_A=0XF80 // declaramos los puertos en su localidad
#byte port_B=0XF81
#byte port_C=0XF82
#byte port_D=0XF83
// variables
int8 conversion; // variable de conversion
void main()
{
float temp,conversion;// valor temporal
lcd_init(); //
lcd_putc("Cargando."); //Visualiza el carácter c en la siguiente posición del LCD.
delay_ms(200); // use delay especificando la frecuencia del reloj
lcd_putc("\f");
lcd_putc("Cargando..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando...");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando ..");
delay_ms(200);
lcd_putc("\f");
lcd_putc("Cargando .");
delay_ms(200);
SET_TRIS_a(0b00000001); //leer puerto A
setup_adc_ports(AN0_TO_AN4|vss_vdd);
setup_adc(ADC_CLOCK_DIV_8);
enable_interrupts(global); //control en el programa principal para permitiro no que se atienda la interrupción , Lo que va dentro del paréntesis en cada una de ellas, es el tipo de interrupción que manejamos
while(true) //permite ejecutar una o mas sentencias en tanto se cumpla una condición.
{
set_adc_channel(0); // comando para definir cuando el va a realizar la interrupcion
delay_us(10);
set_adc_channel(0); // el canal quequeremos leer en este caso lo retenemos por segunda vez
delay_us(10);
conversion= read_adc();// este es el comando de conversion en el cual se toma el valor medido y lo convierte en el void voltimetro
temp = (conversion*196.3)/10000;
lcd_init();
lcd_gotoxy(1,1);// posición de la pantalla
printf(LCD_PUTC,"**Proyecto #3**");
delay_ms(30);
lcd_gotoxy(1,2);// posición de la pantalla
printf(LCD_PUTC,"Volt:= %1.2fv",temp);
delay_ms(800);
}
}
UNEFA
ResponderEliminarIngenieria de Telecomunicaciones
Microprocesadores 6ITTCD01
Profesor: Ing. José Muñoz
Integrantes:
Benitez Yoselyn. C.I. 21.537.774 Moros José. C.I. 18.491.111
Proyecto De Laboratorio Nro.3
En este proyecto nº3 de laboratorio de microprocesadores se realizara la programación y fabricación de un voltímetro con una placa Arduino UNO.
Antes de iniciar la programación definiremos que es un voltímetro, este un instrumento que ayuda a medir la diferencia de potencial entre dos puntos de un circuito eléctrico. Para realizar dichas medidas, se debe colocar el voltímetro en paralelo.
Para realizar el voltímetro, los materiales a usar son:
1.- Protoboard (Cant. 1)
2.- Placa Arduino UNO (Cant. 1)
3.- LCD 16X2 (Cant.1)
4.- Cables Conectores para Arduino (Cant. 23)
5.- Resistencias:
* 120 KΩ (Cant. 4)
* 10 KΩ (Cant. 2)
6.- Potenciomentro 10KΩ (Cant. 1)
Al realizar este circuito, hemos logrado llevarlo a un divisor de tensión. Por ser las resistencias iguales, la tensión se dividirá entre tres y, sobre cada resistencia caerá un potencial equivalente a un tercio del voltaje de entrada. Esto se hace para poder medir con seguridad con la Placa Arduino UNO, ya que tiene un cierto límite. Siempre es conveniente tener extrema precaución con el Arduino, porque puede que lo quememos sin darnos cuenta, aunque es difícil.
Ahora procederemos a realizar la programación del Voltímetro, después de la breve explicación antes mencionada.
Código de Programación para Voltímetro:
#include
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
float lectura;
float voltaje=0;
int estado_boton_1=0, estado_boton_2=0,estado_boton_3=0;
int boton_1=6;
int boton_2=7;
int boton_3=8;
void setup()
{
lcd.begin(16, 2);
pinMode(boton_1,INPUT);
pinMode(boton_2,INPUT);
pinMode(boton_3,INPUT);
lcd.setCursor(0,0);
lcd.print("Seleccione boton");
lcd.setCursor(1,1);
lcd.print("1.kV 2.V 3.mV");
Serial.begin(9600);
}
void loop() {
if(digitalRead(boton_1)==HIGH)
{
lcd.clear();
estado_boton_1=1;
estado_boton_2=0;
estado_boton_3=0;
}
else if(digitalRead(boton_2)==HIGH)
{
lcd.clear();
estado_boton_1=0;
estado_boton_2=1;
estado_boton_3=0;
}
else if(digitalRead(boton_3)==HIGH)
{
lcd.clear();
estado_boton_1=0;
estado_boton_2=0;
estado_boton_3=1;
}
if(estado_boton_2==1 && estado_boton_1==0 && estado_boton_3==0)
{
lectura_voltios(1,1);
lcd.setCursor(0,0);
lcd.print("Voltaje medido:");
lcd.setCursor(12, 1);
lcd.print("(V)");
}
else if(estado_boton_2==0 && estado_boton_1==1 && estado_boton_3==0)
{
lectura_voltios(1000,0);
lcd.setCursor(0,0);
lcd.print("Voltaje medido:");
lcd.setCursor(12, 1);
lcd.print("(mV)");
}
else if(estado_boton_2==0 && estado_boton_1==0 && estado_boton_3==1)
{
lectura_voltios(0.001,4);
lcd.setCursor(0,0);
lcd.print("Voltaje medido:");
lcd.setCursor(12, 1);
lcd.print("(kV)");
}
}
void lectura_voltios(float unidad, int decimales)
{
lectura=analogRead(0);
voltaje = ((5*float(lectura))/1024);
lcd.setCursor(0, 1);
lcd.print(float(voltaje)*3*unidad,decimales);
delay(200);
}