Huanca Marcelo LAB3

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 6

UNIVERSIDAD PRIVADA DEL VALLE

FACULTAD DE INFORMATICA Y ELECTRONICA


INGENIERIA ELECTRONICA Evaluación
CAMPUS TIQUIPAYA

MICROPROCESADORES I

Informe de Practica de Laboratorio Nº 3

Convertidor Analógico Digital

Grupo “A”

Estudiante: Marcelo W. Huanca A.

Docente: Ing. Gerson Pérez Villarroel

Cochabamba 13 de Octubre del 2021

Gestión II – 2021
❖ Objetivo General:

Parte 1:
Programar el microcontrolador para que realice la lectura de dos entradas analógicas,
conectadas a dos pontenciometros y muestre los valores obtenidos por el ADC en un LCD.

❖ Objetivos específicos:

• Desarrollara un programa que realice la lectura de dos entradas analógicas del


microcontrolador cuyo resultado será desplegado en un LCD
• Se deberá conocer el Funcionamiento del LCD
• Saber como funciona un ADC

❖ Marco Teórico:

Convertidor Analogico Digital

Un conversor o convertidor de señal analógica a digital (Conversor Analógico Digital, CAD; Analog-to-
Digital Converter, ADC) es un dispositivo electrónico capaz de convertir una señal analógica, ya sea de
tensión o corriente, en una señal digital mediante un cuantificador y codificándose en muchos casos en un
código binario en particular. Donde un código es la representación unívoca de los elementos, en este caso,
cada valor numérico binario hace corresponder a un solo valor de tensión o corriente.
En la cuantificación de la señal se produce pérdida de la información que no puede ser recuperada en el
proceso inverso, es decir, en la conversión de señal digital a analógica y esto es debido a que se truncan los
valores entre 2 niveles de cuantificación, mientras mayor cantidad de bits mayor resolución y por lo tanto
menor información perdida.
Se utiliza en equipos electrónicos como computadoras, grabadores de sonido y de vídeo, y equipos de
telecomunicaciones.

❖ Enunciado de la Experiencia:

• En este laboratorio se tuvo que programar en AVR(microchip Studio).


• También se vio el uso y funcionamiento en proteus de LCD
• Funcionamiento del ADC y reflejar los datos en un LCD
❖ Diseño:

Código
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>

#define LCD_DPRT PORTD //PORT de datos del LCD


#define LCD_DDDR DDRD //DDR de datos del LCD
#define LCD_DPIN PIND //PIN de datos del LCD
#define LCD_D4 PD4
#define LCD_D5 PD5
#define LCD_D6 PD6
#define LCD_D7 PD7
#define LCD_CPRT PORTD //PORT de comandos del LCD
#define LCD_CDDR DDRD //DDR de comandos del LCD
#define LCD_CPIN PIND //PIN de comandos del LCD
#define LCD_RS PD0 //LCD RS
#define LCD_EN PD1 //LCD EN

/* PROTOTIPOS DEL LCD */


void lcdWrite4(uint8_t);
void lcdCommand(uint8_t cmd);
void lcdData(uint8_t data);
void lcdInit(void);
void lcdGotoxy(uint8_t x, uint8_t y);
void lcdPrint(char*str);

int main(void)
{
uint16_t valor1,valor2;
char txt[4]; // Vector usado para la conversion de entero a cadena
ADMUX=0b01000000; //Vref= AVcc y justificacion a la derecha
ADCSRA=0b10000111; // Habilitar modulo ADC y prescalador de 128
DIDR0=0b00000011; //deshabilitar buffer digital del canal 0,1
lcdInit();
lcdCommand(0x0C);
lcdCommand(0x80);
lcdPrint("ADC0:");
lcdGotoxy(0,1);
lcdPrint("ADC1:");
while (1)
{
ADMUX=0b01000000; //Habilitar el canal 0;
ADCSRA|=(1<<ADSC); //Iniciar conversion
while((ADCSRA & (1<<ADIF))==0);
valor1=ADC;
ADMUX=0b01000001; //Habilitar el canal 1;
ADCSRA|=(1<<ADSC); //Iniciar conversion
while((ADCSRA & (1<<ADIF))==0);
valor2=ADC;

lcdCommand(0x86);
lcdPrint(itoa(valor1,txt,10));
lcdCommand(0xC6);
lcdPrint(itoa(valor2,txt,10));
if (valor1<10 ) //si el valor1 es menor a 10
{
lcdCommand(0x87);
lcdPrint(" "); //Borrar el resto de digitos
}
if (valor1<100 && valor1>=10) // Si el valor1 esta entre 10 y 99
{
lcdCommand(0x88);
lcdPrint(" "); //Borrar el resto de digitos
}
if (valor1<1000 && valor1>=100) //Si el valor1 esta entre 100 y 999
{
lcdCommand(0x89);
lcdPrint(" "); //Borrar el resto de digitos
}
if (valor2<10 ) // Si el valor 2 es menor a 10
{
lcdCommand(0xC7);
lcdPrint(" "); //Borrar el resto de digitos
}
if (valor2<100 && valor2>=10) //Si el valor2 esta entre 10 y 99
{
lcdCommand(0xC8);
lcdPrint(" "); //Borrar el resto de digitos
}
if (valor2<1000 && valor2>=100) //Si el valor2 esta entre 100 y 999
{
lcdCommand(0xC9);
lcdPrint(" "); //Borrar el resto de digitos
}
_delay_ms(1);
}
}
//Funciones del LCD

void lcdWrite4(uint8_t dato) //Enviar nibble alto a D4-D7


{
LCD_DPRT=(LCD_DPRT & 0x0F)|(dato & 0xF0); //Enviar el nibble alto a D4-D7
LCD_CPRT|=(1<<LCD_EN); //EN=1, pulso de alto a bajo
_delay_us(1); //Retardo para pulso
LCD_CPRT &=~(1<<LCD_EN); //EN=0, pulso de alto a bajo
}
void lcdCommand(uint8_t cmd)
{
LCD_CPRT &=~(1<<LCD_RS); //RS=0 para comandos
lcdWrite4(cmd); //Enviar nibble alto a D5-D7
_delay_us(100);
lcdWrite4(cmd<<4); //Enviar nible bajo a D4-D7
_delay_us(100);
}
void lcdData(uint8_t data)
{
LCD_CPRT|=(1<<LCD_RS); //RS=1 para datos
lcdWrite4(data); //Nibble alto
_delay_us(100);
lcdWrite4(data<<4); //Nible bajo
_delay_us(100);
}
void lcdGotoxy(uint8_t x, uint8_t y)
{
uint8_t firstCharAdr[]={0x80, 0xC0, 0x94, 0xD4};
lcdCommand(firstCharAdr[y]+x);
_delay_us(100);
}
void lcdPrint(char*str)
{
uint8_t i=0;
while (str[i]!=0)
{
lcdData(str[i]);
i++;
}
}
void lcdInit(void)
{
LCD_CDDR|= (1<<LCD_D4)|(1<<LCD_D5)|(1<<LCD_D6)|(1<<LCD_D7);
LCD_DDDR|= (1<<LCD_RS)|(1<<LCD_EN);
_delay_ms(50); //Espera inicializacion de encendido de LCD
LCD_CPRT &= ~(1<<LCD_EN); //LCD_EN = 0
LCD_CPRT &= ~(1<<LCD_RS); //RS = 0 para
lcdWrite4(0x30);
_delay_ms(5);
lcdWrite4(0x30);
_delay_us(100);
lcdWrite4(0x30);
_delay_us (100);
lcdWrite4(0x20);
lcdCommand (0x28); //2 lineas , caracter 5x7.
lcdCommand (0x0E); //Display ON, cursor
lcdCommand (0x01); //Limpiar
_delay_ms (2);
lcdCommand (0x06); //Desplazr cursor a la derecha
}

❖ Simulación:
❖ Cuestionario:

• Explicar el funcionamiento del ADC.


R.- Es un sistema que puede transformar señales de tipo analogico a tipo digital.

• Explicar el proceso de cuantificación del ADC. ¿Cuál es el rango de valores del ADC del
microcontrolador?
R.- El proceso de cuantificación digital es posterior a la etapa de muestreo que es toman valores de
amplitud de una determinada señal analógica, un ADC maneja una entrada analógica un numero
binario de 10bits, es decir los valores que puede llegar a operar son de 0 a 1023.

❖ Conclusiones:

En este laboratorio se realizó con éxito para el ADC, ya que fue un programa algo largo pero con una
lógica algo sencilla.

❖ Bibliografía:
https://www.rinconingenieril.es/ajustar-senal-adc/
https://es.wikipedia.org/wiki/Cuantificaci%C3%B3n_digital#:~:text=El%20proceso%20de%20cuantifica
ci%C3%B3n%20digital,muestra%20pero%20no%20es%20digital.

También podría gustarte