UNIVERSIDAD CATÓLICA DE SANTA MARÍA

FACULTAD DE CIENCIAS E INGENIERAS FÍSICAS Y FORMALES

ESCUELA PROFESIONAL INGENIERÍA ELECTRÓNICA

ADC-VOLTIMETRO

CURSO: MICROCONTROLADORES

INGENIERO JUAN QUISPE YAUYO

AUTORES:

CÁCERES VILLAVICENCIO CARLOS

LLANOS ZAYRITUPAC JORMAN

PUMA CHÁVEZ VÍCTOR JOAQUÍN

AREQUIPA

2017
 ENTRENADOR PARA PIC 16F877A

1. OBJETIVOS

Poder crear y entender el Entrenador

Aprender a compilar un programa en c compiler y asm
Aprender a grabar un programa en el pic

2. CONSIDERACIONES ANTES DE LA PRACTICA

Se ruega el cuidado y uso adecuado de entrenador de microcontroladores por

parte del usuario
Evitar tener al alcance bebidas o cualquier líquido que pueda ocasionar un
corto circuito y fallos en el entrenador.
La manipulación del microcontrolador debe ser con demasiado cuidado
evitando tocarlo directamente con la mano o peor con ropa de lana por
riesgo a que este se queme por la estática. Estos dispositivos son muy
sensibles por lo que se recomienda de ser posible manipularlos con guantes
sintéticos.
Sobre la práctica:
El alumno debe tener instalado el programa PIC C COMPILER, el cual será
el software a través del cual se hará la programación y compilación del
programa.
El alumno debe tener instalado el programa PICKIT 2, el cual será que
queme el programa hexadecimal generado por el compilador en el
microcontrolador.

3. MATERIALES

Disponibles en el Laboratorio:
Entrenador para microcontroladores 16f877a
Pickit 2 (Grabador) y su respectivo cable a la PC
Alimentación del entrenador (Cargador a 12v)
 Entrenador PIC

Pickit 2 (Grabador)
 Es necesario comprar:
Microcontrolador 16F877A (precio aproximado 18 soles)
1 cristal oscilador 20 MHz (precio 1 sol)
2 bombillos a 12v (opcional)

Microcontrolador 16F877A y oscilador de 20 MHz

4. MARCO TEÓRICO

1. ENTRENADOR PIC
El entrenador universal es una herramienta de ensayo que permite evaluar de forma
cómoda y rápida las aplicaciones desarrolladas por el usuario; mediante un sencillo
cableado sin soldadura, es posible conectar y asociar distintos periféricos en las
líneas de entradas y salidas de un microcontrolador pic o Arduino.
El presente entrenador es exclusivamente para PIC de 40 pines, es decir el
16F877A, pero en general es posible también hacer el uso de este para todos los
microcontroladores de la familia 16FXX o 18FXX haciendo las respectivas
conexiones de los pines.
El entrenador cuenta con diversos módulos, los módulos que posee el entrenador
están clasificados y son:
 4 entradas digitales
 8 salidas digitales
 2 entradas analógicas
 2 salidas a relay
 1 sensor infrarrojo
 1 módulo de ultrasonido
 1 módulo bluetooth
 Comunicación serial con MAX232 / Módulo USB a RS232
 1 control de corriente continua de motor con driver L293D
 1 sensor de temperatura analógico con LM35
 1 sensor de temperatura digital DS18B20
 1 control de potencia a corriente alterna con optocoplador
 4 displays de 7 segmentos
  1 Reloj en Tiempo Real con DS1307
 1 comunicación con memoria EEPROM
 1 módulo para Display de Cristal Líquido (LCD 16X2)
 1 módulo para para LCD gráfico
 1 módulo de comunicación USB
 2 servomotores
 1 buzzer
 1 teclado matricial
 Alimentación directa a 12v o usb 5v
En la presente práctica sólo se hará uso de una entrada digital por pulsador y las
salidas conectadas a 2 relay.

2. GRABADOR PICKIT 2
El pickit 2 clone es un diseño de la empresa GS ATEC - GRUPO SYNERGO de
igual manera que el entrenador anteriormente mencionado. El programador PicKit2,
es una herramienta de programación para desarrollo de bajo costo. Es capaz de
programar la mayoría de los microcontroladores y memorias seriales EEPROM de
Microchip. El programador PicKit2, es una herramienta de programación para
desarrollo de bajo costo. Es capaz de programar la mayoría de los
microcontroladores y memorias seriales EEPROM de Microchip. Sin este, no se
llevaría a cabo la programación de microcontroladores por lo cual es fundamental.
Actualmente existe en el mercado el pickit 3, el cual es una versión mejorada capaz
de grabar en una mayor cantidad de familias de microcontroladores de Microchip.

3. COMPILADOR CCS

PIC C Compiler es un inteligente y muy optimizado compilador C que contienen

operadores estándar del lenguaje C y funciones incorporados en bibliotecas que son
específicas a los registros de PIC, proporcionando a los desarrolladores una
herramienta poderosa para el acceso al hardware las funciones del dispositivo desde
el nivel de lenguaje C.

El compilador CCS contiene más de 307 funciones integradas que simplifiquen el

acceso al hardware, mientras que la producción eficiente y altamente optimizado
código. Se incluyen funciones de hardware del dispositivo de características tales
como:

 Temporizadores y módulos PWM

 Convertidores A / D de datos on-chip
 EEPROM.
 Controladores LCD
 Memoria externa buses

En mi opinión personal, PIC C compiler tiene un entorno bastante amigable con el

usuario que desconoce de programación en microcontroladores, por lo cual es a mi
parecer, la mejor herramienta para empezar la programación en pics. Se hará una
tabla comparativa de los compiladores más comunes del mercado resaltando las
cualidades del CCS, así como sus ventajas y desventajas.

Funciones
Ejemplos en
Compilador Entorno Lenguaje Pre-
la Red
determinadas
CCS Amigable c Bastantes Bastantes
MPLAB XC8 Normal c Muchos Muchas
MPLAB XIDE Normal asm Bastantes Pocas
MicroC Muy Amigable c Pocos Pocas
Demasiado Diagramas
Flow Code Muy pocos -
Amigable de Flujo

La facilidad que posee PIC C Compiler es que ya lo trae todo predefinido, tan sólo
accediendo al File del microcontrolador que se está usando durante la
programación; por lo cual no es de vital importancia tener el datasheet del
microcontrolador a la mano, como si lo es necesario al programar con MPASM,
MPLAB XIDE, MPLAB XC8 o PIC18.
La desventaja de CCS contra estos programas es que no se tiene acceso directo al
microcontrolador y por lo tanto no se realizan las instrucciones en el tiempo
establecido, debido a que debe primero transformarse a lenguaje de bajo nivel y eso
tardará algunos microsegundos que en aplicaciones específicas puede ser mucho. En
aplicaciones prácticas como la presente este pequeño retraso no es de importancia.
Por último, programas como MicroC o Flow Code son muy limitados con respecto a
la información en la red y limitados en cuanto a las funciones que ya tienen
preestablecidas. Sólo incluyen las funciones básicas, sin contar el tiempo que
tardarían en convertir sus instrucciones a bajo nivel.

4. PROGRAMA PICKIT 2

El PICkit ™ 2 Desarrollo programador / depurador (PG164120) es una herramienta

de desarrollo de bajo costo con una interfaz fácil de usar para la programación y la
depuración de las familias de Flash de Microchip de microcontroladores. La interfaz
de programación Windows® soporta toda la función de la línea de base (PIC10F,
PIC12F5xx, PIC16F5xx), de rango medio (PIC12F6xx, PIC16F), las familias
PIC18F, PIC24, dsPIC30, dsPIC33, y PIC32 de microcontroladores de 8 bits, 16
bits y 32 bits, y muchos productos EEPROM serie microchip.
 5. PIC16F877A

Este microcontrolador de rango medio es fabricado por MicroChip familia a la cual

se le denomina PIC. El modelo 16F877A posee 40 pines, los cuales están
distribuidos de la siguiente manera:

Además, posee varias características que hacen a este microcontrolador un

dispositivo muy versátil, eficiente y práctico para ser empleado en la presente
práctica y para el uso del entrenador. Entre sus principales características tenemos
las siguientes:
 6. Emsamblador

El lenguaje ensamblador, o assembler (en inglés assembly language y la abreviación asm),

es un lenguaje de programación de bajo nivel. Consiste en un conjunto de mnemónicos que
representan instrucciones básicas para
los computadores, microprocesadores, microcontroladores y otros circuitos
integrados programables. Implementa una representación simbólica de los códigos de
máquina binarios y otras constantes necesarias para programar una arquitectura de
procesador y constituye la representación más directa del código máquina específico para
cada arquitectura legible por un programador. Cada arquitectura de procesador tiene su
propio lenguaje ensamblador que usualmente es definida por el fabricante de hardware, y
está basada en los mnemónicos que simbolizan los pasos de procesamiento
(las instrucciones), los registros del procesador, las posiciones de memoria y otras
características del lenguaje. Un lenguaje ensamblador es por lo tanto específico de
cierta arquitectura de computador física (o virtual). Esto está en contraste con la mayoría de
los lenguajes de programación de alto nivel, que idealmente son portátiles.
Un programa utilitario llamado ensamblador es usado para traducir sentencias del lenguaje
ensamblador al código de máquina del computador objetivo. El ensamblador realiza una
traducción más o menos isomorfa (un mapeo de uno a uno) desde las sentencias
mnemónicas a las instrucciones y datos de máquina. Esto está en contraste con los
lenguajes de alto nivel, en los cuales una sola declaración generalmente da lugar a muchas
instrucciones de máquina.
Muchos sofisticados ensambladores ofrecen mecanismos adicionales para facilitar el
desarrollo del programa, controlar el proceso de ensamblaje, y la ayuda de depuración.
Particularmente, la mayoría de los ensambladores modernos incluyen una facilidad
de macro (descrita más abajo), y se llaman macro ensambladores.
Fue usado principalmente en los inicios del desarrollo de software, cuando aún no se
contaba con potentes lenguajes de alto nivel y los recursos eran limitados. Actualmente se
utiliza con frecuencia en ambientes académicos y de investigación, especialmente cuando
se requiere la manipulación directa de hardware, alto rendimiento, o un uso de recursos
controlado y reducido. También es utilizado en el desarrollo de controladores de
dispositivo (en inglés, device drivers) y en el desarrollo de sistemas operativos, debido a la
necesidad del acceso directo a las instrucciones de la máquina. Muchos dispositivos
programables (como los microcontroladores) aún cuentan con el ensamblador como la
única manera de ser manipulados.

2. DESARROLLO

1. Abrir MPLAB

2. Crear un nuevo documento en blanco

 3. Seleccionamos que PicKit usaremos para quemar nuestro Pic

-Le ponemos nombre a nuestro archivo

 4. El siguiente código es de un voltímetro de 5v
El cual es un código ADC el cual toma las muestras de una entrada analógica la
convierte a digital y la el resultado lo entrega en el display, usando bucles para
poder obtener la lectura de esta entrada cada segundo, así poder variar la entrada y
el resultado sea el mismo.

LIST P=16F877A
#INCLUDE "P16F877A.INC"
__CONFIG 0x3F39

ORG 0x00
M EQU 0x20
N EQU 0x21
O EQU 0x22
LECTURA_H EQU 0x23
CUENT_U EQU 0x24
CUENT_D EQU 0x25
CUENT_C EQU 0x26
CONTADOR_H EQU 0x27
DELAY1_F1 EQU 0x28
DELAY1_F2 EQU 0x29
DELAY2_F1 EQU 0x2A
DELAY2_F2 EQU 0x2B
DELAY2_F3 EQU 0x2C
CUENT_M EQU 0x2D
CONTADOR_L EQU 0x2E
LECTURA_L EQU 0x30
LIMITE_MUL EQU 0x31
LEC_MUL_H EQU 0x32
LEC_MUL_L EQU 0x33

BCF STATUS,RP1
 BSF STATUS,RP0
BSF TRISA,0
CLRF TRISB
CLRF TRISC
BANKSEL ADCON0
MOVLW B'11000001'
MOVWF ADCON0
BANKSEL ADCON1
MOVLW B'10001110'
MOVWF ADCON1
BANKSEL PORTB
CLRF CUENT_U
CLRF CUENT_D
CLRF CUENT_C
CLRF CUENT_M
CLRF CONTADOR_L
CLRF CONTADOR_H
CLRF PORTC
CLRF PORTB

MOVLW D'1'
MOVWF DELAY2_F1
MOVLW D'200'
MOVWF DELAY2_F2
MOVLW D'200'
MOVWF DELAY2_F3
CALL DELAY2
CALL LCD_IN
PRINCIPAL

CALL LIMPIAR_LCD
CALL CURSOR_EN_INICIO
CLRF CUENT_U
CLRF CUENT_D
CLRF CUENT_C
CLRF CUENT_M
CLRF CONTADOR_H
CLRF CONTADOR_L

MOVLW D'5'
MOVWF LIMITE_MUL
BSF ADCON0,GO_DONE

BUCLE
BTFSC ADCON0, GO_DONE
GOTO BUCLE
BANKSEL ADRESL
MOVF ADRESL,0
BANKSEL ADRESH
MOVWF LECTURA_L
MOVF ADRESH,0
MOVWF LECTURA_H
MOVF LECTURA_H,0
MOVWF LEC_MUL_H
MOVF LECTURA_L,0
MOVWF LEC_MUL_L
 CALL MULTIPLICACION_PROBE

CALL SEPARAR

CALL TEXTO_1
MOVLW D'1'
MOVWF DELAY2_F1
MOVLW D'200'
MOVWF DELAY2_F2
MOVLW D'200'
MOVWF DELAY2_F3
CALL DELAY2
GOTO PRINCIPAL

MULTIPLICACION_PROBE

MOVF LIMITE_MUL,0
BTFSC STATUS,2
GOTO MUL_CERO

MULTIPLICACION

DECF LIMITE_MUL,1
BANKSEL ADCON0
BCF STATUS,2
MOVF LIMITE_MUL,0

BTFSC STATUS,2
RETURN

MOVF LEC_MUL_H,0
ADDWF LECTURA_H,1

MOVF LEC_MUL_L,0
ADDWF LECTURA_L,0
MOVWF LECTURA_L
BTFSC STATUS,0
INCF LECTURA_H,1

GOTO MULTIPLICACION

MUL_CERO
CLRF LECTURA_L
CLRF LECTURA_H
RETURN

;///////////////////////////////////////////////
;/////////////////////IMPRIMIR//////////////////
;///////////////////////////////////////////////

TEXTO_1
MOVLW 'V'
MOVWF PORTB
CALL MANDAR
MOVLW 'O'
MOVWF PORTB
 CALL MANDAR
MOVLW 'L'
MOVWF PORTB
CALL MANDAR
MOVLW 'T'
MOVWF PORTB
CALL MANDAR
MOVLW B'00111010'
MOVWF PORTB
CALL MANDAR
MOVF CUENT_M,0
CALL CAMBIA_FORMATO
MOVWF PORTB
CALL MANDAR
MOVLW B'00101100'
MOVWF PORTB
CALL MANDAR
MOVF CUENT_C,0
CALL CAMBIA_FORMATO
MOVWF PORTB
CALL MANDAR ;ENVIA LETRA
MOVF CUENT_D,0
CALL CAMBIA_FORMATO
MOVWF PORTB
CALL MANDAR
MOVF CUENT_U,0
CALL CAMBIA_FORMATO
MOVWF PORTB
CALL MANDAR
RETURN

;///////////////////////////////////////////////
;/////////////////////SEPARAR///////////////////
;///////////////////////////////////////////////

SEPARAR

CALL CERO_TOTAL ;comprueba si el numero es cero

W=1 si es diferente de cero--w=0 si es 0
BTFSC STATUS,2 ;si Z=1 retorna
RETURN
GOTO INCREMENTO
P_INCRE
INCF CUENT_U,1
MOVF CUENT_U,0
SUBLW D'10'
BTFSS STATUS,2
GOTO SEPARAR
CLRF CUENT_U
INCF CUENT_D,1
MOVF CUENT_D,0
SUBLW D'10'
BTFSS STATUS,2
GOTO SEPARAR
CLRF CUENT_D
INCF CUENT_C,1
MOVF CUENT_C,0
 SUBLW D'10'
BTFSS STATUS,2
GOTO SEPARAR
CLRF CUENT_C
INCF CUENT_M,1
GOTO SEPARAR

CERO_TOTAL
MOVF CONTADOR_H,0
SUBWF LECTURA_H,0
BTFSS STATUS,2
RETLW B'00000001'
MOVF CONTADOR_L,0
SUBWF LECTURA_L,0
BTFSS STATUS,2
RETLW B'00000001'
RETLW B'00000000'

INCREMENTO
BCF STATUS,2
INCF CONTADOR_L,0
BTFSS STATUS,2
GOTO SIN_CARRY
GOTO CON_CARRY

CON_CARRY
BCF STATUS,2
CLRF CONTADOR_L
INCF CONTADOR_H,1
GOTO P_INCRE

SIN_CARRY
INCF CONTADOR_L,1
GOTO P_INCRE

;///////////////////////////////////////////////
;/////////////////////LIBRERIA-LCD///////////////////
;///////////////////////////////////////////////

LCD_IN
CALL LIMPIAR_LCD
CALL CURSOR_EN_INICIO
CALL MODO_FUNCIONAMIENTO
RETURN

LIMPIAR_LCD
BCF PORTC,0 ;RS=0
MOVLW 0X01
MOVWF PORTB ;LIMPIA LCD
CALL EJECUTA ;PULSO DE HABILITADOR (23010US)

CURSOR_EN_INICIO
BCF PORTC,0 ;RS=0
MOVLW 0X0C
MOVWF PORTB ;CURSOR EN INICIO
CALL EJECUTA ;PULSO DE HABILITACION
MODO_FUNCIONAMIENTO
BCF PORTC,0 ;RS=0
MOVLW 0X3C ;
MOVWF PORTB ;MODO DE FUNCIONAMIENTO 8BITS, 2LINEAS, 5X11
TAMAÑO
CALL EJECUTA ;PULSO DE HABILITACION

EJECUTA
BSF PORTC,1 ;E=1
MOVLW D'10'
MOVWF DELAY1_F1
MOVLW D'55'
MOVWF DELAY1_F2
CALL DELAY1 ;RETARDO+CALL=1695US
BCF PORTC,1 ;E=0
RETURN

MANDAR
BSF PORTC,0 ;RS=1 PARA ESCRITURA
CALL EJECUTA ;PULSO DE HABILITACION
RETURN
;///////////////////////////////////////////////
;///////////////////IMPRIMIR////////////////////
;///////////////////////////////////////////////

CAMBIA_FORMATO
ADDWF PCL,1
RETLW B'00110000'
RETLW B'00110001'
RETLW B'00110010'
RETLW B'00110011'
RETLW B'00110100'
RETLW B'00110101'
RETLW B'00110110'
RETLW B'00110111'
RETLW B'00111000'
RETLW B'00111001'

;///////////////////////////////////////////////
;///////////////RETARDO Y DEMORAS///////////////
;///////////////////////////////////////////////

DELAY1 ;1689US+2U+1US+1US=1693US APROX

MOVF DELAY1_F1,0;1US---10
MOVWF M ;1US
DOS
MOVF DELAY1_F2,0;1US---55
MOVWF N ;1US
UNO
DECFSZ N,1 ;1US
GOTO UNO ;2US-----NOP(1US)/////164US=====>(3*N)-1
DECFSZ M,1 ;1US
GOTO DOS ;2US-----NOP(1US)/////1689US====>(164+1+1+1+2)*M-1
RETURN ;2US

DELAY2 ;1/4 DE SEGUNDO APROX

 MOVF DELAY2_F1,0;---1
MOVWF M
TRESX
MOVF DELAY2_F2,0;---200
MOVWF N
DOSX
MOVF DELAY2_F3,0;---200
MOVWF O
UNOX
NOP
NOP
DECFSZ O,1
GOTO UNOX
DECFSZ N,1
GOTO DOSX
DECFSZ M,1
GOTO TRESX
RETURN
END

5. Compilar el archivo
6. Conectar el PIC 16F877A en el respectivo slot de 40 pines del Pickit 2

7. Conectar con el cable usb el Hadware del Pickit2 al pc

 Se enciende el led verde

8. Abrir el Pickit 2 Programmer

9. Verificar que reconoció el PIC 16F877A

10. Leer el dispositivo

11. Eliminar el Programa Anterior

12. Verificar que el pic esté en blanco

13. Importar el hexadecimal del programa creado

14. Grabar el programa

 Se encienden los 3 leds al grabar
15. Desconectamos el cable del Pickit2
16. Colocamos el pic en el entrenador
17. Se hacen las conexiones respectivas
18. Activamos la alimentación
19. Resultados

CONECTAMOS USAREMOS EL PUERTO B

CONECTAMOS LAS ENTRADAS PARA NUESTRO DISPLAY

CONECTAMOS NUESTRO OSCILADOR DE 20MHZ

 NUESTRA ENTRADA DE 5V CON UN POTENCIOMETRO , LA CUAL
ES ALIMENTADA POR EL ENTRENADOR QUE TIENE UN MODULO
DE SALIDA DE 5 V

Al encender vamos variando el voltaje con el potenciómetro

y podemos observar la salida en el display y para comprobar y calcular el error
conectamos un multímetro
Comprobamos que el error es de 4%
3. SIMULACIÓN

Al compilar nuestro código, nos dará de resultado un código .hex el cual es usado
para nuestro pic , el botón programe file es donde tenemos que buscar nuestro
código para que el programa lo pueda simular
Podemos observar que al variar el potenciómetro igual que en la practica el voltaje
disminuye
Se adjuntó programas en ASM y en Proteous8.5, así como también un video de las
muestras realizadas en prácticas de laboratorio
4. INFORMACIÓN ADICIONAL

Es posible adquirir de manera personal el entrenador o el grabador de pic si alguien

está interesado.

Contacto: