Microcontroladores: mikroBasic para microcontroladores PIC

Copyright 2010 Christian Bodington
Todos los derechos reservados. Esta publicación no puede ser reproducida,
ni en todo ni en partes, ni registrada en o transmitida por un sistema de
recuperación de información, en ninguna forma ni por ningún medio, sea
mecánico, fotoquímico, electrónico, magnético, electroóptico, por fotocopia
o cualquier otro, sin permiso previo por escrito del autor.
Ilustrado y Editado por: Christian Bodington Esteva
Diseño de la portada / Arte por: Christian Bodington Esteva
WWW.CONEXIONELECTRONICA.COM

i
CONTENIDO
Prologo.
Capitulo I.
1.1.- Herramientas de diseño.
1.2.- Entorno de Desarrollo Integrado de mikroBasic.
1.3.- Estructura de un programa.
1.4.- Crear un nuevo proyecto en mikroBasic.
1.5.- Conociendo el entorno de desarrollo integrado.
1.6.- Componentes y operadores en mikroBasic.
1.6.1.- Subrutinas.
1.6.2.- Variables.
1.6.3.- Arrays.
1.6.4.- Constantes.
1.6.5.- Alias.
1.6.6.- Operadores Aritméticos.
1.6.7.- Operadores Bit a Bit.
1.6.8.- Operadores de Comparación.
Capitulo II.
2.1.- Arquitectura Básica del microcontrolador PIC16F877.
2.2.- El oscilador externo.
2.3.- Circuito de Reset.
2.4.- Consideraciones técnicas de diseño.
2.4.1.- Estado lógico de un pin I/O.
2.4.2.- Lectura de un estado lógico en un pin I/O.
2.4.3.- El opto-acoplador como dispositivo de enlace.
2.4.4.- Fuente de poder 5Vdc – 3.3Vdc.
2.5.- Configuración de puertos de entrada y salida en un microcontrolador PIC.
2.6.- Primeros ejemplos de programación en mikroBasic.
2.6.1.- Ejemplo #1. Control de Leds.
2.6.2.- Ejemplo #2. Control de Leds con pulsadores.
2.6.3.- Ejemplo #3. Librería Button.

ii
Capitulo III. Pantallas LCD y GLCD.
3.1.- Pantallas LCD, estudio de la librería LCD de mikroBasic.
3.1.1.- Identificación de los pines de una pantalla LCD.
3.1.2.- Conexión y configuración de una pantalla LCD.
3.1.3.- Rutina Lcd_Init().
3.1.4.- Rutina Lcd_Cmd().
3.1.5.- Rutina Lcd_Out().
3.1.5.1.- Ejemplo #4. Imprimir mensaje en pantalla LCD.
3.1.5.2.- Ejemplo #5. Uso de comandos en pantalla LCD.
3.1.5.3.- Ejemplo #5.1. Uso de comandos en pantalla LCD.
3.1.6.- Rutina Lcd_Out_Cp().
3.1.6.1.- Ejemplo #6. Uso de la rutina Lcd_Out_Cp().
3.1.7.- Rutina Lcd_Chr().
3.1.8.- Rutina Lcd_Chr_Cp().
3.1.8.1.- Ejemplo #7. Uso de rutinas Lcd_Chr() y Lcd_Chr_Cp().
3.2.- Parámetros de rutinas cargados en variables.
3.2.1.- Ejemplo #8. Uso de variables como parámetros.
3.2.2.- Ejemplo #9. Imprime el contenido de dos variables tipo String.
3.3.- Imprimir el contenido de una variable en una pantalla LCD.
3.3.1.- Ejemplo #10. Imprimir el contenido de una variable.
3.3.2.- Ejemplo #11. Imprime el resultado de una operación,
suma y resta de un número cargado en una variable
a través de pulsadores.
3.3.3.- Ejemplo #12. Crear un menú de opciones en la pantalla.
3.4.- Pantalla Gráfica o GLCD (Graphic Liquid Crystal Display).
3.4.1.- Conexión y configuración de una pantalla GLCD.
3.5.- Librería GLCD.
3.5.1.- Rutina Glcd_Init().
3.5.2.- Ejemplo #13. Uso de la rutina Glcd_Init().
3.5.3.- Módulo de Fuentes en mikroBasic.

iii
3.5.3.1.- Ejemplo #14. Cómo incluir un módulo de fuentes.
3.5.4.- Rutina Glcd_Fill().
3.5.5.- Rutina Glcd_Set_Font().
3.5.6.- Rutina Glcd_Write_Text().
3.5.6.1.- Ejemplo #15. Imprimir el contenido de una
variable tipo Word.
3.5.7.- Rutina Glcd_Dot(x, y, color).
3.5.7.1.- Ejemplo #16. Encender o apagar un pixel específico.
3.5.7.2.- Ejemplo #17. Cambio de color o color inverso en la pantalla.
3.5.7.3.- Ejemplo #18. Cambio de estado de un pixel.
3.5.8.- Rutina Glcd_Line(x1, y1, x2, y2, color).
3.5.8.1.- Ejemplo #19. Dibuja línea entre coordenadas específicas.
3.5.8.2.- Ejemplo #20. Dibuja línea entre coordenadas, color inverso.
3.5.9.- Rutina Glcd_V_Line(y1, y2, x, color).
3.5.9.1.- Ejemplo #21. Dibuja línea vertical entre
coordenadas específicas.
3.5.10.- Rutina Glcd_H_Line(x1, x2, y, color).
3.5.10.1.- Ejemplo #22. Dibuja línea horizontal entre coordenadas.
3.5.11.- Rutina Glcd_Rectangle(x1, y1, x2, y2, color).
3.5.11.1.- Ejemplo #23. Dibuja un cuadrado o rectángulo.
3.5.11.2.- Ejemplo #24. Dibuja una serie de rectángulos consecutivos.
3.5.12.- Rutina Glcd_Box(x1, y1, x2, y2, color).
3.5.12.1.- Ejemplo #25. Dibuja un cuadrado o rectángulo sólido.
3.5.12.2.- Ejemplo #26. Dibuja un cuadrado o rectángulo sólido,
color inverso.
3.5.13.- Glcd_Circle(x, y, radio, color).
3.5.13.1.- Ejemplo #27. Dibuja un círculo en la pantalla.
3.5.13.2.- Ejemplo #28. Dibuja un círculo, color inverso.
3.5.13.3.- Ejemplo #29. Dibuja círculos consecutivos.

iv
Capítulo IV. Librería Trigon – Funciones Trigonométricas.
4.1.- Funciones Trigonométricas. Sin(x), Sinh(x), Cos(x), Cosh(x), Tan(x), Tanh(x)
Asin(x), Acos(x), Atan(x), Atan2(x, y), Log(x), Log10(x), Sqrt(x), Exp(x),
Pow(x, y), fabs(x).
4.1.1.- Ejemplo #30. Cálculo del seno de un valor x.
4.1.2.- Ejemplo #31. Cálculo del coseno de un valor x.
4.1.3.- Ejemplo #32. Cálculo de la tangente de un valor x.
4.1.4.- Ejemplo #33. Calculadora.
Capítulo V. Librería Sound.
5.1.- Rutinas de la librería de sonido de mikroBasic. Cálculos de frecuencias de la
escala musical.
5.1.1.- Ejemplo #34. Reproduce las notas de la escala musical en la octava A4,
y muestra las frecuencias a través de la pantalla LCD.
5.1.2.- Ejemplo #35. Elaboración de un piano de una octava musical.
Capítulo VI. Teclado Matricial y Teclado PS/2.
6.1.- Teclado Matricial.
6.2.- Librería KeyPad.
6.2.1.- Rutina KeyPad_Init().
6.2.2.- Rutina KeyPad_Key_Press().
6.2.2.1.- Ejemplo #36. Lectura de un teclado matricial.
6.2.2.2.- Ejemplo #37. Como enmascarar el resultado de la lectura
del teclado matricial.
6.3.- Teclado PS/2.
6.4.- Librería PS/2.
6.4.1.- Rutina Ps2_Config().
6.4.2.- Rutina Ps2_Key_Read().
6.4.2.1.- Ejemplo #38. Lectura de un teclado PS/2.
6.4.2.2.- Ejemplo #39. Lectura de teclas de funciones especiales.
6.4.2.3.- Ejemplo #40. Mostrar símbolo ASCII y valor correspondiente
a una tecla presionada.

v
Capítulo VII. Memoria de Datos EEPROM.
7.1.- Memoria de datos EEPROM.
7.2.- Librería EEPROM.
7.1.1.- Rutina EEPROM_Read().
7.2.2.- Rutina EEPROM_Write().
7.2.2.1.- Ejemplo #41. Sistema de control de acceso con clave de 6
dígitos almacenada en la memoria EEPROM.
7.2.2.2.- Ejemplo #42. Sistema de control de acceso mejorado. Se
permite el cambio de clave desde el teclado.
Capítulo VIII. Conversor A/D.
8.1.- El conversor A/D.
8.1.1.- El registro ADCON0.
8.1.3.- Ejemplo #43. Conversión A/D de una señal analógica.
8.1.4.- Ejemplo #44. Conversión A/D con voltaje de referencia.
8.1.5.- Ejemplo #45. Conversión A/D, datos adicionales en la pantalla.
8.2.- El Acelerómetro.
8.2.1.- Ejemplo #46. Acelerómetro 3D, conversión A/D de datos en los
ejes X, Y, Z.
8.2.2.- Cálculo del voltaje de entrada del conversor A/D.
8.2.3.- Cálculo de la aceleración en base al voltaje calculado en cada eje.
8.2.4.- Ejemplo #47. Visualizar voltaje y aceleración calculada en la GLCD.
8.3.- Termocupla.
8.3.1.- AD594/AD595, cálculo de la linealidad.
8.3.2.- Ejemplo #48. Termómetro digital con termocupla tipo J.
Capítulo IX. Comunicación Serial Asíncrona RS232.
9.1.- Comunicación Serial Asíncrona RS232.
9.2.- Librería UART.
9.2.1.- Rutina UART1_Init().
9.2.2.- Rutina UART1_Data_Ready().

vi
9.2.3.- Rutina UART1_Read().
9.2.4.- Ejemplo #49. Recepción de datos vía RS232.
9.2.5.- Ejemplo #50. Almacenar y visualizar una cadena de caracteres.
9.2.6.- Rutina UART1_Write().
9.2.7.- Ejemplo #51. Transmisión y recepción de datos vía RS232.
9.3.- ¿Cómo extraer información específica de una cadena de datos?.
9.3.1.- Ejemplo #52. Extraer información de una cadena de datos.
9.4.- Módulo de comunicaciones BlueTooth.
9.4.1.- Widcomm BlueTooth Software 5.0.1.3900.
9.4.2.- Comunicación Serial inalámbrica BlueTooth.
9.5.- Módulo GPS (OEM), comunicación serial RS232.
9.5.1.- Protocolo NMEA.
9.5.2.- Ejemplo #53. Extrae coordenadas geográficas y número de
satélites utilizador por el módulo GPS.
9.6.- Programación en Visual Basic 6.0 para ejemplos de comunicación serial
RS232.
9.6.1.- Ejemplo #54. Captura de datos enviados desde un módulo VB.
9.6.2.- Ejemplo #55. Captura de datos enviados desde un microcontrolador
a una hoja de cálculo de Microsoft Excel.
Capítulo X. Multi Media Card (MMC) y Secure Card (SD) Memory.
10.1.- Librería MMC/SD.
10.1.1.- Rutina Mmc_Init().
10.1.2.- Rutina Mmc_Read_Cid().
10.1.3.- Rutina Mmc_Read_Csd().
10.1.4.- Rutina Mmc_Write_Sector().
10.1.5.- Rutina Mmc_Read_Sector().
10.2.- Registro CID.
10.2.1.- Ejemplo #56. Lectura del registro CID en una memoria SD.
10.3.- Registro CSD Versión 2.0.
10.3.1.- Ejemplo #57. Lectura del registro CSD en una memoria SD.

vii
10.4.- WinHex.
10.4.1.- Ejemplo #58. Almacenamiento de datos en sectores específicos
de la memoria SD.
10.4.2.- Ejemplo #59. Lectura de datos de un sector específico.
10.5.- Sistema de archivos FAT.
10.5.1.- Rutina Mmc_Fat_Init().
10.5.2.- Rutina Mmc_Fat_QuickFormat().
10.5.3.- Ejemplo #60. Cómo dar formato a una tarjeta de memoria SD
desde el microcontrolador PIC.
10.5.4.- ¿Cómo crear un archivo en una tarjeta de memoria SD?.
10.5.5.- Rutina Mmc_Fat_Assign().
10.5.6.- Ejemplo #61. Crear un archivo .txt con atributo de sólo lectura.
10.5.7.- Ejemplo #62. Crear un archivo .txt con atributo de sólo lectura y
archivo oculto.
10.5.8.- Ejemplo #63. Crear un subdirectorio o carpeta.
10.5.9.- Ejemplo #64. Atributo “Archivo”.
10.6.- Ingresar datos en un archivo almacenado en la memoria SD.
10.6.1.- Ejemplo #65. Almacena cadena de caracteres enviada desde la
terminal de comunicaciones de mikroBasic vía RS232.
10.7.- Asignar fecha y hora a un archivo.
10.7.1.- Ejemplo #66. Asigna fecha y hora a un archivo.
10.8.- Verificar si un archivo de nombre específico existe.
10.8.1.- Ejemplo #67. Verifica si existe un archivo en la memoria SD.
10.9.- Insertar datos en un archivo existente.
10.9.1.- Ejemplo #68. Insertar cadena de datos en un archivo existente.

viii
Capítulo XI. Servomotores.
11.1.- ¿Qué es un Servomotor?.
11.1.1.- Ejemplo #69. Control de un servomotor.
11.1.2.- Ejemplo #70. Posiciones pre-definidas.
Capítulo XII. PWM.
12.1.- PWM.
12.2.- Librería PWM.
12.2.1.- Rutina PWM1_Init().
12.2.2.- Rutina PWM1_Set_Duty().
12.2.3.- Rutina PWM1_Start().
12.2.4.- Rutina PWM1_Stop().
12.2.5.- PWM2.
12.2.6.- Ejemplo #71. Genera señal PWM controlada.
12.2.7.- Ejemplo #72. Control de un Motor DC.
Apéndice A. Tabla ASCII.
Apéndice B. Prácticas en formato digital.
Bibliografía.

Prólogo
La segunda edición del libro “Basic para Microcontroladores PIC” esta basado en el estudio
del compilador mikroBasic Pro, de la empresa MikroElektronika. El contenido de esta obra
facilita un verdadero inicio rápido en la programación de microcontroladores PIC gracias a
una completa librería diseñada para el control de una gran variedad de periféricos,
facilitando el desarrollo de proyectos electrónicos a través de 72 ejemplos prácticos,
analizados y comentados detalladamente en base a los microcontroladores PIC16F877,
PIC18F442, PIC18F452 y PIC18F458.
La mayoría de los proyectos han sido desarrollados con la ayuda del entrenador de
microcontroladores “EasyPic5” de mikroElektronika, además de una serie de componentes
adicionales de fácil adquisición y bajo costo.
Al igual que en la primera edición, la metodología empleada ha sido orientada para que el
lector pueda expandir sus conocimientos para generar nuevas ideas en la implimentación de
este compilador sobre esta tecnología ya anteriormente estudiada. Esta obra es la primera
parte de un extenso estudio de mikroBasic, adaptado a nuestro idioma y pensado para
aquellas personas con conocimientos básicos en la programación de estos componentes.
Los puntos de estudios más importantes han sido el control de puertos, pantallas LCD y
GLCD, sonido, funciones trigonométricas, teclado matricial y PS/2, memoria de datos
EEPROM, conversor A/D, control de dispositivos como potenciómetros, acelerómetro 3D,
termocupla, comunicación serial RS-232, BlueTooth, módulos GPS, programación en Visual
Basic para control de puertos, multimedia card (MMC y SD), almacenamiento masivo de
datos, creación de archivos en formato FAT desde el microcontrolador PIC, servomotores y
PWM.
MikroBasic hace posible el desarrollo de nuevas ideas en muy poco tiempo, haciendo del
estudio de los microcontroladores un tema sencillo y accesible.
Christian Bodington Esteva

_______________________________________________________________________________________
Contenido - Basic para Microcontroladores PIC – www.conexionelectronica.com – Christian Bodington Esteva
2
Capitulo I
1.1.- Herramientas de Diseño
En la elaboración de proyectos electrónicos con microcontroladores PIC, resulta muy
importante considerar una serie de herramientas que vamos a describir a continuación y las
cuales pueden ser proporcionadas en su gran mayoría por la empresa Mikroelektronika
(www.mikroe.com). Esta empresa se ha dado a la tarea de diseñar tanto el software de
programación para microcontroladores PIC, como el hardware necesario para poder
aprender todo lo relacionado al tema que a continuación estaremos abordando a través de
muchos ejemplos prácticos los cuales tienen una gran variedad de periféricos disponibles,
tales como pantallas LCD, GLCD, teclados matriciales, teclados PS/2, dispositivos de
comunicación serial, entre otros.
Software: para la programación en Lenguaje Basic, contamos con el Ambiente Integrado de
Desarrollo MikroBasic de MikroElektronika. Con esta herramienta estaremos realizando la
programación en cada uno de los proyectos propuestos a partir del capítulo II.
Figura 1.1 (Fuente: http://www.mikroe.com)

_______________________________________________________________________________________
3
Programador de Microcontroladores PIC de MikroElektronika: es un programador de
la familia Flash de Microchip, de conexión universal USB, el cual puede ser acoplado
a una placa de circuito impreso la cual contiene todas las bases disponibles del tipo
DIP como lo demuestra la figura 1.2. También es posible hacer arreglos en nuestros
circuitos para dejar un puerto de conexión para el programador, y así poder realizar
cambios en nuestros programas sin retirar el microcontrolador de nuestros diseños.
Esta opción, denominada ICSP (In-Circuit Serial Programming), simplifica el trabajo a
la hora de reprogramar nuestros diseños.
Figura 1.2 (Fuente: http://www.mikroe.com)

_______________________________________________________________________________________
4
Placa entrenadora de Mikroelektronika: una herramienta diseñada para trabajar en
conjunto con los compiladores de mikroElektronika, proporcionan diferentes módulos
interconectados entre ellos, facilitando la elaboración de prácticas con
microcontroladores. Estos entrenadores de microcontroladores además incorporan su
propio programador de microcontroladores PIC de conexión USB 2.0. El entrenador
recomendado en esta edición es el EasyPIC5.
Figura 1.3 (Fuente: http://www.mikroe.com/en/tools/easypic5)
Herramientas de corte, extractor de circuitos integrados, cable rígido para conexiones
en la placa de prototipos.
Figura 1.4

_______________________________________________________________________________________
5
Osciloscopio: este instrumento se requiere para el desarrollo de algunas prácticas en
las cuales se hace necesario medir las señales generadas desde el microcontrolador.
Figura 1.5
Componentes electrónicos: microcontroladores PIC en los modelos definidos en cada
ejemplo práctico, resistencias, diodos, servomotores, condensadores, cristales y otros
componentes de fácil adquisición. Cada proyecto cuenta con una tabla en la cual se
describen los componentes electrónicos que deberán ser utilizados en el cada
montaje.
Figura 1.6

_______________________________________________________________________________________
6
1.2.- Entorno de Desarrollo Integrado de mikroBasic.
MikroBasic cuenta con su propia interfaz de programación la cual podemos descargar de la
pagina oficial http://www.mikroe.com en su versión de demostración y con sus respectivas
limitaciones. Para obtener una versión completa de este compilador, será necesario efectuar
la compra on-line, la cual puede ser tangible o no tangible, es decir, para descargar on-line
una vez aprobada la compra, o para recibir en nuestros hogares en físico.
El link para la descarga es el siguiente:
http://www.mikroe.com/en/download/
Figura 1.7
El archivo descargado del link anteriormente mencionado luce como se muestra a
continuación:
Figura 1.8

_______________________________________________________________________________________
7
Haciendo doble clic sobre el mismo, iniciamos el proceso de instalación del programa.
Figura 1.9
Figura 1.10
En la figura anterior podemos ver la ventana de bienvenida, y al hacer clic en siguiente, la
ventana del contrato de licencia para el usuario.

_______________________________________________________________________________________
8
Figura 1.11
Para poder continuar con la instalación, seleccionamos la opción de aceptación de los
términos explicados en el acuerdo de licencia, y seguidamente hacemos clic en “Next”.
A continuación veremos los componentes del programa disponibles para la instalación:
El compilador.
Los archivos de ayuda del compilador.
Ejemplos de programas desarrollados para los módulos del circuito entrenador
de Mikroelektronika.

_______________________________________________________________________________________
9
Figura 1.12
Al hacer clic en el botón “Next”, veremos la ruta de instalación por defecto del compilador en
nuestro PC.
Figura 1.13

_______________________________________________________________________________________
10
Podemos dejar la ruta sugerida o podemos cambiarla según convenga. Al haber
seleccionado anteriormente todos los componentes en la instalación, podemos observar que
el espacio requerido se acerca a los 75 MB.
Ahora para iniciar la instalación, hacemos clic en el botón “Install”, acción con la cual
veremos el progreso de la instalación en nuestro disco, como lo demuestran las siguientes
imágenes:
Figura 1.14
Figura 1.15

_______________________________________________________________________________________
11
Figura 1.16
Figura 1.17

_______________________________________________________________________________________
12
Al hacer clic en el botón “Finish”, el programa de instalación nos preguntará si deseamos
instalar el soporte ICD (In-Circuit Debugger) de mikroBasic:
Figura 1.18
Figura 1.19
Al hacer clic en el botón “Si” veremos la ventana de bienvenida a la guía de instalación, y
seguidamente nos encontraremos con la ventana del acuerdo de licencia de programa.

_______________________________________________________________________________________
13
Figura 1.20
Seleccionamos la opción para la aceptación de la licencia y hacemos clic en el botón “Next”.
Un componente adicional a seleccionar es el software para el programador de
microcontroladores de mikroelektronika. Si ya poseemos el hardware correspondiente a este
software, seleccionamos la casilla para la instalación del software “PicFlash”.
Este programador viene integrado en las tarjetas entrenadoras, e incluso se vende por
separado en su versión USB.

_______________________________________________________________________________________
14
Figura 1.21
Haciendo clic en el botón “Next”, estaremos viendo la ruta de instalación por defecto o ruta
sugerida por el programa de instalación. Esta ruta se puede mantener igual o ser cambiada
según convenga al usuario.
Una vez seleccionada la ruta, hacemos clic en el botón “Install” y esperamos a que termine
el proceso de instalación como se muestra en las siguientes imágenes:
Figura 1.22

_______________________________________________________________________________________
15
Figura 1.23
El siguiente paso será la instalación para el soporte Lv18PICFLASH:
Figura 1.24

_______________________________________________________________________________________
16
Figura 1.25
Figura 1.26

_______________________________________________________________________________________
17
Figura 1.27
Figura 1.28

_______________________________________________________________________________________
18
Figura 1.29
También será necesaria la instalación de los drivers para el programador de
microcontroladores de mikroelektronika:
Figura 1.30

_______________________________________________________________________________________
19
Figura 1.31
Terminada la instalación de drivers, la instalación de mikroBasic nos pregunta si deseamos
ejecutar el software inmediatamente. Al hacer clic en el botón “Si” podremos ver que la
interfaz de programación se abre y queda lista para iniciar a programar nuestros proyectos.
Inicialmente se podrá observar que la misma abre automáticamente un ejemplo de
programación en lenguaje Basic, “Led_Blinking.pbas”.
Figura 1.32

_______________________________________________________________________________________
20
Figura 1.33
Figura 1.34

_______________________________________________________________________________________
21
1.3.- Estructura de un programa: Para que nuestros programas tengan una apariencia
ordenada y se facilite la comprensión del mismo ante otros programadores que deseen
realizar mejoras a éste, es necesario establecer una estructura que nos permita identificar
fácilmente cada una de las partes que lo componen.
Figura 1.35
En la figura 1.35 se puede observar la estructura básica de un programa hecho en
mikroBasic, y en la cual hemos identificado las cuatro secciones que consideramos más
importantes para lograr un programa bien estructurado.
Sección A: Corresponde al encabezado del programa, en el cual siempre es conveniente
incorporar información básica del mismo, como el nombre, la identificación de autor,
Copyright, fecha de elaboración o fecha de los últimos cambios realizados, versión del
programa que se está realizando, e incluso una breve descripción acerca del objetivo del
programa y su aplicación en un determinado circuito electrónico.
Sección B: Esta sección empieza en la columna cero del editor de texto de mikroBasic, y en
ella se pueden declarar variables, sub-funciones, configuraciones de dispositivos periféricos
y etiquetas de cada una de las subrutinas que serán programadas.
Las etiquetas identifican puntos específicos o subrutinas dentro de un programa. Son
definidas por el programador y deben tener al final de cada una de ellas el símbolo de “dos
puntos”, que definen el final de la misma.
A
B C D

_______________________________________________________________________________________
22
Sección C: Estará destinada para las instrucciones de programa y la misma está separada
de la columna cero del editor de texto por una tabulación, es decir, cuando el cursor se
encuentra en la columna cero, presionamos una vez la tecla “TAB”, y de esta manera
establecemos un espacio mínimo, siempre igual o superior entre la sección B y C.
Sección D: Esta destinada para realizar comentarios acerca de la función que estará
cumpliendo una instrucción específica en nuestro programa. Cada comentario debe
empezar siempre con una comilla simple como se muestra a continuación:
' Define el Oscilador para un Cristal
' de 4 Mhz.
Cuando un comentario es demasiado extenso, podemos continuar el mismo en la siguiente
línea, siempre que la frase comience con su respectiva comilla.
Los comentarios ayudan al diseñador a identificar cada línea de programa o cada una de las
funciones de cada subrutina, garantizando así una buena documentación en cada uno de
los programas que realizamos.

_______________________________________________________________________________________
23
1.4.- Crear un nuevo proyecto en mikroBasic:
Saber como crear un proyecto en mikroBasic es un paso sencillo pero muy importante, ya
que de ello depende que nuestros programas sean compilados correctamente.
Veamos a continuación los pasos a seguir:
Desplegamos el menú “Project” y seguidamente seleccionamos la opción “New
Project”. Enseguida veremos la ventana de bienvenida.
Figura 1.36
En el paso 1, seleccionamos la opción “Next” para pasar a la siguiente ventana en la
cual elegiremos el modelo de microcontrolador que deseamos utilizar en nuestro
proyecto.

_______________________________________________________________________________________
24
Figura 1.37
En el paso 2 debemos seleccionar el valor exacto del cristal que estaremos utilizando
como oscilador externo de nuestro microcontrolador PIC.
Figura 1.38

_______________________________________________________________________________________
25
En el paso 3, debemos seleccionar la ruta sobre la cual deseamos grabar el proyecto,
al igual que el nombre del proyecto. Para esto, simplemente seleccionamos la carpeta
señalada en la figura 1.39, a través de la cual podremos acceder a cualquiera de las
unidades de almacenamiento en nuestro PC.
Figura 1.39
Figura 1.40

_______________________________________________________________________________________
26
Figura 1.41
En el paso 4 es posible agregar a nuestros proyectos archivos que contengan código
creado con anterioridad, los cuales pudieran contener subrutinas generalizadas para
el control de periféricos comunes como pantallas LCD o teclados. En caso de no
disponer de ningún archivo adicional para el proyecto, simplemente continuamos
seleccionando la opción “Next”.
Figura 1.42

_______________________________________________________________________________________
27
En el paso 5 tenemos la opción de incluir todas las librerías disponibles para el
microcontrolador anteriormente seleccionado en nuestro proyecto. También tenemos
la opción de no incluir ninguna de ellas. Esto se debe a que mikroBasic cuenta con
una amplia selección de librerías para el control de dispositivos periféricos o procesos
de cálculo o conversión de datos que nos permitirán hacer de la programación algo
fácil y rápida a la hora de diseñar un programa, pero no necesariamente
necesitaremos de todas las librerías en un solo proyecto. Si elegimos la opción
“Include All” podremos estar seguros de que cada librería empleada en nuestro
programa funcionará correctamente. Si elegimos la opción “Include None (Advance)”
tendremos que realizar la selección de las librerías que deseamos utilizar desde el
administrador de librerías de mikroBasic, el cual veremos mas adelante.
Figura 1.43
El paso 6 en la creación de un nuevo proyecto nos dice que hemos finalizado la
configuración del mismo. MikroBasic esta ahora listo para empezar a programar
nuestro primer proyecto, tal y como se puede observar en la figura 1.44.

_______________________________________________________________________________________
28
Figura 1.44
Figura 1.45

_______________________________________________________________________________________
29
1.5.- Conociendo el entorno de desarrollo integrado.
MikroBasic cuenta con un entorno de desarrollo integrado bastante completo y apropiado.
En él podremos encontrar una serie de opciones y herramientas, de las cuales hemos
resaltado las que consideramos más importantes a la hora de elaborar un programa.
Figura 1.46
En la sección A, podemos encontrar las opciones del menú principal, además de todos los
accesos directos a cada funcion del software a través de pequeños botones ordenados y de
fácil acceso.
La sección B es el editor en el cual se escribirán los programas de cada proyecto bajo las
recomendaciones realizadas en punto 1.3 de este capítulo.
A
B
C
D
E

_______________________________________________________________________________________
30
En la sección C se puede observar el administrador de librerías, el cual deberá ser tomado
en cuenta siempre que nuestros proyectos incluyan el uso de cualquiera de las librerías
disponibles en mikroBasic.
En la sección D se encuentra en explorador de código el cual resulta my útil cuando
realizamos programas muy extensos. En él se muestra cada elemento declarado en un
programa. Podremos acceder directamente a uno de estos elementos haciendo doble clic en
ellos.
La sección E muestra dos pestañas importantes. La primera pestaña se llama “Messages” o
“Mensajes”, contiene un área en la cual se mostrarán los resultados del procedimiento de
compilación de un programa. Si se genera un error de compilación, éste será mostrado en
esta ventana mostrando el tipo de error y su ubicación en la ventana de edición. La segunda
pestaña se llama “Quick Converter” y contiene una herramienta de conversión de unidades
en diferentes formatos.
Veamos a continuación la descripción de cada menú en la sección A de la imagen 1.46.
Menú “File”:
Figura 1.47
New Unit: Abre una nueva ventana de edición de programas para mikroBasic. En
esta ventana escribiremos el código de programa de nuestros proyectos.
Open: A través de esta opción podremos abrir cualquier archivo asociado a
nuestros proyectos de programación.
Recent Files: Al seleccionar esta opción, podremos ver una lista de nombres de los
archivos mas recientes en los cuales hemos estado trabajando.

_______________________________________________________________________________________
31
Save: Salva o guarda los cambios realizados en la ventana de programación.
Save As: Salva o guarda los cambios realizados en la ventana de programación
con un nombre o ruta diferente.
Close: Cierra la ventana de código activa.
Print Preview: Una vista previa de la ventana de código activa antes de la
impresión.
Print: Imprime la ventana de código Activa.
Exit: Cierra el entorno de programación de mikroBasic.
Menú “Edit”:
Figura 1.48
Undo: Deshace el último cambio en el editor.
Redo: Rehace el último cambio en el editor.

_______________________________________________________________________________________
32
Cut: Corta el texto seleccionado y lo coloca en el portapapeles.
Copy: Copia el texto seleccionado y lo coloca en el portapapeles.
Paste: Pega el contenido del portapapeles en el editor.
Delete: Borra el texto seleccionado.
Select All: Selecciona todo el texto en la ventana activa del editor.
Find: Despliega la ventana de búsqueda del editor de texto.
Find Next: Busca la siguiente coincidencia de texto en la ventana activa del
editor.
Find Previous: Busca la coincidencia anterior en la ventana activa del editor.
Replace: Reemplaza el texto especificado por el usuario en la ventana activa del
editor.
Find In Files: Busca un texto en la ventana o ventanas activas, e incluso de
alguna carpeta especificada por el usuario.
Goto Line: Va a la línea deseada en la ventana activa del editor.
Sub-Menú “Advanced”:
Figura 1.49

_______________________________________________________________________________________
33
Comment: Convierte líneas de código de programa previamente seleccionadas en
comentarios. Si no hemos seleccionado ninguna línea de código, simplemente
aparece una comilla simple, asignando el resto de la línea como un espacio
disponible para realizar comentarios.
Uncomment: Remueve la propiedad de comentario de una o varias líneas
seleccionadas.
Indent: Aplica una tabulación o sangría al texto seleccionado.
Outdent: Elimina una tabulación o sangría al texto seleccionado.
Lowercase: Cambia todo el texto seleccionado a minúsculas.
Uppercase: Cambia todo el texto seleccionado a mayúsculas.
Titlecase: Cambia a mayúscula la primera letra del texto seleccionado.
Menú “View”:
Figura 1.50
Sub-Menú “Toolbars”: A través de este sub-menú podemos seleccionar cuales
herramientas estarán visibles o disponibles en la sección “A” del entorno de desarrollo
integrado.

_______________________________________________________________________________________
34
Figura 1.51
Sub-menú “Debug Windows”: A través de este sub-menú podemos seleccionar las
ventanas disponibles en el depurador de mikroBasic.
Figura 1.52
Routine List o Lista de Rutinas: Muestra la ventana en la cual podremos ver
una lista de todas las rutinas que hemos creado en un programa. Al hacer doble clic
sobre el nombre de la rutina, el editor posiciona el cursor al inicio de ésta.

_______________________________________________________________________________________
35
Figura 1.53
Project Settings: Despliega la ventana de configuración del proyecto, en la cual
podemos seleccionar el modelo de microcontrolador PIC que deseamos utilizar en
nuestro proyecto, la frecuencia o valor del cristal del oscilador externo, y por último las
opciones disponibles para la compilación y ventana de depuración de mikroBasic.
Figura 1.54

_______________________________________________________________________________________
36
Code Explorer o Explorador de Código: Despliega la ventana del explorador de
código de mikroBasic.
Figura 1.55
Project Manager o Administrador de Proyectos: A través de esta ventana es
posible acceder a todo el contenido del proyecto.
Figura 1.56
Esta ventana posee además botones de acceso rápido a algunas funciones importantes:
o Salvar un grupo de proyectos: En mikroBasic es posible tener más de
un proyecto abierto en entorno de desarrollo integrado. Este botón nos
permitirá almacenar este grupo de proyectos bajo un único nombre. En la

_______________________________________________________________________________________
37
siguiente figura se muestra un ejemplo de un grupo de proyectos disponibles
en la ventana de administración de proyectos.
Figura 1.57
Abrir un grupo de proyectos: A través de esta opción podremos abrir un
grupo de proyectos previamente creado.
Cerrar un Proyecto.
Cerrar un grupo de proyectos.
Agregar un proyecto al grupo de proyectos actual.
Eliminar un proyecto del grupo de proyectos actual.
Agregar un archivo al proyecto activo.
Eliminar un archivo del proyecto activo.
Compilar un proyecto.
Inicia el software de programación de microcontroladores PIC de
mikroElektronika.

_______________________________________________________________________________________
38
Library Manager o Administrador de Librerías: El administrador de librerías de
mikroBasic contiene todas las librerías disponibles para un microcontrolador
previamente seleccionado.
Figura 1.58
Actualiza el administrador de librerías.
Compila todas las librerías disponibles.
Incluye todas las librerías en un proyecto.
No incluye ninguna de las librerías en el proyecto.
Restaura el estado de las librerías justo antes de la última grabación del
proyecto.
Bookmarks o Marcadores: Esta opción despliega una ventana en la cual podremos
agregar accesos directos a puntos específicos en un programa. Al hacer doble clic en
alguno de estos accesos directos, el cursor se ubicará automáticamente en la línea o
dirección especificada.

_______________________________________________________________________________________
39
Figura 1.59
Quick Converter o Conversor rápido de datos: Despliega la ventana de conversión
de datos de mikroBasic.
Messages o Mensajes: Despliega la ventana de mensajes de error del compilador.
Macro Editor o Editor de Macros: Despliega una ventana en la cual podremos
grabar una secuencia de acciones sobre el entorno de desarrollo integrado, es decir,
podríamos grabar una secuencia de ordenes que nos permita por ejemplo abrir el
terminal de comunicaciones de mikroBasic y hacer que se conecte bajo ciertos
parámetros específicos con tan solo activar su Macro correspondiente.
Figura 1.60
Inicia el proceso de grabación en la secuencia de pulsaciones de teclas
sobre el entorno de desarrollo integrado de mikroBasic.
Detiene el proceso de grabación de la secuencia de pulsaciones de teclas.

_______________________________________________________________________________________
40
Permite ejecutar una Macro previamente grabada.
Crea un nuevo Macro.
Borra la Macro seleccionada.
Windows o Ventanas: A través de esta opción podremos ver un listado de todas las
ventanas desplegables en el entorno de desarrollo integrado de mikroBasic.
Menú “Project”:
Figura 1.61

_______________________________________________________________________________________
41
Build: Compila el proyecto activo en el entorno de desarrollo de integrado.
Build All Projects: Compila todos los proyectos abiertos.
Build + Program: Compila y programa el proyecto activo.
View Assembly: Muestra el código generado en lenguaje ensamblador.
View Statistics: Muestra las estadísticas del proyecto activo.
View Listing: Muestra el listado de asignación de memoria del PIC: direcciones
de instrucciones, registros, las rutinas y las etiquetas.
Edit Search Paths: Edita rutas de búsqueda.
Clean Project Folder: Esta opción limpia o borra de la carpeta de proyecto los
archivos generados cuando se realiza la compilación del mismo.
Add File To Project: Permite agregar cualquier tipo de archivo relacionado a un
proyecto en desarrollo.
Remove File From Project: Borra un archivo específico de un proyecto.
Import Project: Permite importar proyectos de versiones anteriores de
mikroBasic.
New Project: Abre el asistente para la creación de nuevos proyectos.
Open Project: Abre un proyecto existente.
Save Project: Salva un proyecto activo en el entorno de desarrollo integrado.
Edit Project: Despliega una ventana a través de la cual podemos configurar los
fusibles de programación del microcontrolador.

_______________________________________________________________________________________
42
Figura 1.62
Open Project Group: Abrir un grupo de proyectos: A través de esta opción
podremos abrir un grupo de proyectos previamente creado.
Close Project Group: Cerrar un grupo de proyectos.
Save Project As: Permite salvar un proyecto con un nombre diferente.
Recent Projects: Muestra un listado de los proyectos abiertos últimamente.
Close Project: Cierra un proyecto activo.
Menú “Run”: Contiene todos los comandos relacionados con el depurador de mikroBasic.
Figura 1.63

_______________________________________________________________________________________
43
Menú “Tools”: Contiene todas las herramientas disponibles en mikroBasic.
Figura 1.64
Menú “Help”: A través de este menú podremos acceder a toda la ayuda disponible acerca
del compilador, accesos directos al foro de discusión, página Web oficial de
mikroElektronika, formulario de registro del compilador e información de registro actual.
Figura 1.65

_______________________________________________________________________________________
44
Nota Importante: En la versión DEMO del compilador mikroBasic, el archivo de salida .HEX
generado cuando compilamos un programa esta limitado a 2K bytes.
Es muy importante que adquiera la licencia correspondiente para la versión completa del
compilador, para poder llevar a cabo todos los ejemplos propuestos en esta edición.
La licencia es suministrada en línea por la empresa “MikroElektronika” y el proceso de
registro es sumamente sencillo. Tener la licencia del compilador nos garantiza además el
acceso al soporte técnico de la empresa y el acceso a las continuas actualizaciones que se
realizan para mejorar el producto.
Figura 1.66

_______________________________________________________________________________________
45
1.6.- Componentes y operadores en mikroBasic.
1.6.1.- Subrutinas: Una subrutina se presenta como un algoritmo separado del algoritmo
principal, y estará destinado a resolver una tarea específica. Las subrutinas pueden ser
referidas cada vez que sea necesario, llamando a la etiqueta que corresponde a ésta, la cual
debe ir siempre al inicio de la misma.
Led1:
For Z = 0 To 9
LED = Encendido
Delay_ms(1000)
LED = Apagado
Delay_ms(1000)
Next Z
GoTo Inicio
End.
MikroBasic cuenta con una serie de herramientas de programación entre las cuales
podemos mencionar las etiquetas, variables, identificadores, constantes, comentarios y
símbolos entre otras.
Algunas de estas herramientas son de uso obligatorio a la hora de realizar un programa, y
otras que no son de uso obligatorio, nos facilitarán el trabajo considerablemente.
1.6.2.- Variables: En las variables podemos almacenar datos temporalmente, los cuales
podrán ser consultados o modificados cada vez que sea necesario. Normalmente la
definición de variables se hace al inicio de un programa y para ello se utiliza el formato:
DIM “variable” As “tipo de variable”
Tipo de Variable Tamaño Rango
bit 1–bit 0 or 1
sbit 1–bit 0 or 1
byte, char 8–bit 0 .. 255
short 8–bit -127 .. 128
word 16–bit 0 .. 65535
integer 16–bit -32768 .. 32767
longword 32–bit 0 .. 4294967295
longint 32–bit -2147483648 .. 2147483647
float 32–bit ±1.17549435082 * 10-38
.. ±6.80564774407 * 1038
Figura 1.67
El nombre de la variable es elegido por el programador y el tipo de variable se define según
el tipo de dato que se desea almacenar temporalmente.
Subrutina
Etiqueta

_______________________________________________________________________________________
46
1.6.3.- Arrays: Las variables Arrays tienen un determinado número de “elementos”, definido
según el tamaño de la variable. Las variables Arrays tipo Bit, pueden almacenar 256
elementos; las variables Arrays tipo Byte pueden almacenar hasta 96 elementos y las
variables Arrays tipo Word hasta 48 elementos, los cuales se pueden accesar en cualquiera
de los tres casos a través de un índice. Este índice se específica entre corchetes como se
muestra en los siguientes ejemplos:
Para declarar una variable tipo Array utilizamos la siguiente sintaxis:
Dim Variable As Byte[7]
El primer elemento de esta variable es Dato[0] y el último elemento es Dato[7], lo cual
significa que hemos declarado una variable array de 8 elementos. En este caso podemos
almacenar un byte en cada elemento, siempre que especifiquemos el índice.
Ejemplo: Almacenar en cada elemento de la variable “Dato” los valores 200, 15, 56, 75, 80,
20, 33, 45.
Dato[0] = 200
Dato[1] = 15
Dato[2] = 56
Dato[3] = 75
Dato[4] = 80
Dato[5] = 20
Dato[6] = 33
Dato[7] = 45
En algunos casos se debe verificar la hoja de datos del microcontrolador, ya que la cantidad
de elementos que se pueden almacenar en variables Arrays tipo Byte o Word puede variar
según el modelo del mismo.
1.6.4.- Constantes: Ayudan a identificar un valor constante en nuestro programa, facilitando
aún más la comprensión del mismo a la hora de verificar su funcionamiento. Las constantes
deben ser siempre declaradas al inicio de un programa, junto con las variables (área de
declaración).
La sintaxis para declarar una constante es la siguiente:
Const “nombre de la constante” As “tipo” = “Valor”
Ejemplo:
Const PI As Float = 3.1416
Const Meses As Byte[12] = (31,28,31,30,31,30,31,31,30,31,30,31)

_______________________________________________________________________________________
47
1.6.5.- Alias: Proveen un nombre único y específico a elementos o variables dentro de
nuestro programa. Para definir un símbolo, utilizamos la palabra “Symbol”, seguida del alias
del elemento, el símbolo de igualdad “=”, y por último el elemento en cuestión:
Symbol {alias} = {elemento}
Por ejemplo, si deseamos controlar un motor DC a través de uno de los pines del puerto A
de un microcontrolador, resultaría mucho mas sencillo referirse a este pin como “Motor”, en
vez de referirse a él como “PortA.0”.
Entonces,
Symbol Motor = PORTA.0
Veamos otros ejemplos:
Symbol Relay = PORTB.0
Symbol Sensor = PORTA.0
Symbol LED = PORTA.1
Symbol RC0 = PORTC.0
1.6.6.- Operadores Aritméticos: Entre los operadores aritméticos más utilizados tenemos
los que se muestran en la siguiente tabla:
Operadores Operación Operandos Resultado
+ Suma
byte, short, word, integer,
longint, longword, float
- Resta
* multiplicación
word, integer, longint,
longword, float
/ División, en punto flotante.
float
div
División, redondea hacia el
entero mas cercano.
longint, longword
longint, longword
mod
módulo, devuelve el resto de
la división entera (no se
puede utilizar con punto
flotante)
longint, longword
longint, longword
Figura 1.68

_______________________________________________________________________________________
48
1.6.7.- Operadores Bit a Bit: En la siguiente tabla veremos los operadores binarios
proporcionados para el lenguaje Basic:
Operador Operación
and AND Lógico
or OR Lógico
xor OR Exclusiva (XOR)
not NOT Lógico
Figura 1.69
Con estos operadores resulta muy sencillo realizar operaciones binarias, como lo demuestra
el siguiente ejemplo:
Si aplicamos una AND lógica, donde deseamos filtrar los siete bits más significativos del
valor almacenado en la siguiente variable:
Var1 = %00101001
Entonces,
Var1 = Var1 and %00000001
El resultado de esta operación es Var1 = %00000001
1.6.8.- Operadores de Comparación: Los operadores de comparación normalmente son
utilizados con la instrucción If…Them… para realizar comparaciones entre variables o datos
extraídos de alguna operación aritmética.
Operador Operación
= Igual
<> Diferente
> Mayor que
< Menor que
>= Mayor o Igual que
<= Menor o Igual que
Figura 1.70

_______________________________________________________________________________________
49
Capitulo II
2.1.- Arquitectura básica del microcontrolador PIC16F877.
Para iniciar con el estudio de la programación en mikroBasic, nos plantearemos tres
objetivos que consideramos importantes para entrar en materia:
Familiarizarse con la arquitectura básica de los microcontroladores que estaremos
empleando a lo largo de esta edición.
Familiarizarse con la estructura de programa de mikroBasic, muy importante a la hora
de realizar un programa ordenado y libre de errores, por muy pequeño que este sea.
El estudio de las primeras prácticas, cortas y de fácil comprensión con el fin de
adquirir confianza en el uso de instrucciones y librerías de mikroBasic.
Arquitectura Básica del microcontrolador PIC16F877:
Uno de los microcontroladores seleccionados para el estudio de la programación de
microcontroladores en lenguaje Basic ha sido el PIC16F877. Veamos a continuación
algunas de sus características técnicas más importantes:
CPU: Risc (Reduced Instruction Set Computer).
Frecuencia Máxima: 20 Mhz.
Memoria RAM: 368 x 8 Bytes de memoria de Datos.
EEPROM: 256 x 8 Bytes de memoria EEPROM de datos.
Memoria de programa Flash: 8KB x 14 Bits.
Protección de código programable.
Voltaje de Operación: 2.0 voltios a 5.5 voltios.
Bajo consumo de potencia: < 0.6 mA typical @ 3V, 4 Mhz /
kHz.
5 puertos digitales programables como entrada/salida: A, B, C, D, E.
1 conversor A/D de 8 canales x 10 Bits.
Puerto Serial Síncrono (SSP) con SPI e I2C.

_______________________________________________________________________________________
50
Puerto Serial Universal (USART/SCI).
2 Módulos CCP (Capture, Compare, PWM)
3 Timers: Timer0 8 Bits contador/temporizador y pre-escalador de 8 Bits; Timer1 16
Bits contador/temporizador y pre-escalador; Timer2 8 Bits contador/temporizador con
registro de 8 Bits, pre-escalador y Post-Escalador.
Figura 2.1

_______________________________________________________________________________________
51
Descripción de los pines del microcontrolador PIC16F877:
PIN Identificación Descripción del Pin
1 MCLR/Vpp Reset y entrada de voltaje de programación.
2 RA0/AN0 Pin de Entrada/Salida (I/O) del puerto A
3 RA1/AN1 Pin de Entrada/Salida (I/O) del puerto A
4 RA2/AN2/Vref- Pin de Entrada/Salida (I/O) del puerto A
5 RA3/AN3/Vref+ Pin de Entrada/Salida (I/O) del puerto A
6 RA4/TOCKI Pin de Entrada/Salida (I/O) del puerto A
7 RA5/AN4/SS Pin de Entrada/Salida (I/O) del puerto A
8 RE0/RD/AN5 Pin de Entrada/Salida (I/O) del puerto E
9 RE1/WR/AN6 Pin de Entrada/Salida (I/O) del puerto E
10 RE2/CS/AN7 Pin de Entrada/Salida (I/O) del puerto E
11 VDD Pin de Alimentación de 5Vdc
12 VSS Pin de Alimentación a Tierra (GND)
13 OCS2/CLKOUT Salida del oscilador a cristal.
14 OSC1/CLKIN Entrada del oscilador a cristal o fuente externa de reloj.
15 RC0/T1OSO/T1CKI Pin de Entrada/Salida (I/O) del puerto C
16 RC1/T1OSI/CCP2 Pin de Entrada/Salida (I/O) del puerto C
17 RC2/CCP1 Pin de Entrada/Salida (I/O) del puerto C
18 RC3/SCK/SCL Pin de Entrada/Salida (I/O) del puerto C
19 RD0/PSP0 Pin de Entrada/Salida (I/O) del puerto D
23 RC4/SDI/SDA Pin de Entrada/Salida (I/O) del puerto C
24 RC5/SDO Pin de Entrada/Salida (I/O) del puerto C
25 RC6/TX/CK Pin de Entrada/Salida (I/O) del puerto C
26 RC7/RX/DT Pin de Entrada/Salida (I/O) del puerto C
31 VSS Pin de Alimentación a Tierra (GND)
32 VDD Pin de Alimentación de 5Vdc
33 RB0/INT Pin de Entrada/Salida (I/O) del puerto B
34 RB1 Pin de Entrada/Salida (I/O) del puerto B
36 RB3/PGM Pin de Entrada/Salida (I/O) del puerto B
39 RB6/PGC Pin de Entrada/Salida (I/O) del puerto B
40 RB7/PGD Pin de Entrada/Salida (I/O) del puerto B
Figura 2.2

_______________________________________________________________________________________
52
2.2.- El Oscilador externo.
Figura 2.3
Es un circuito indispensable para el funcionamiento del microcontrolador y el cual además,
define la velocidad a la cual va a trabajar. Para hacer funcionar nuestro diseño podemos
elegir entre las siguientes cuatro opciones:
Oscilador LP: Oscilador de bajo consumo (Low Power).
Oscilador XT: Cristal / Resonador.
Oscilador HS: Oscilador de alta velocidad (High Speed).
Oscilador RC: Resistencia / Condensador.
En los modos de oscilador LP, XT y HS el cristal debe ser conectado a los pines 13 y 14,
Osc2/CLKin y Osc1/CLKout respectivamente, como se muestra en la figura 2.4.

_______________________________________________________________________________________
53
Los valores de los condensadores cerámicos vienen dados según la tabla que se muestra a
continuación:
Modo Frecuencia Osc1/CLKin Osc2/CLKout
LP
32 kHz
200 kHz
68 - 100 pF
15 - 33 pF
68 - 100 pF
15 - 33 pF
XT
2 MHz
4 MHz
15 - 33 pF
15 - 33 pF
15 - 33 pF
15 - 33 pF
HS
4 MHz
10 MHz
15 - 33 pF
15 - 33 pF
15 - 33 pF
15 - 33 pF
Figura 2.4
Por ejemplo, para un oscilador tipo XT, podemos utilizar un cristal de cuarzo como el de la
figura 2.5.
Figura 2.5
Al conectar el microcontrolador a la fuente de alimentación de 5 Vdc y medir la señal de
salida del oscilador XT con un osciloscopio, en el pin 14 (Osc2/CLKout) del
microcontrolador, podremos ver la onda generada bajo los siguientes parámetros de
medición seleccionados en el equipo:
Voltios/Div: 200mV
Time/Div: 100ns
Figura 2.6

_______________________________________________________________________________________
54
La lectura de la frecuencia y período en este caso sería la siguiente:
Frecuencia: 3,972 Mhz
Período: 251,71 ns
Cristal de cuarzo TTL: Este tipo de cristal consta de cuatro pines, de los cuales solo tres
están implementados de la siguiente manera:
Figura 2.7
Pin 1: NC (Este pin no se encuentra conectado internamente)
Pin 7: GND
Pin 8: Salida TTL
Pin 14: +5Vdc
En su salida se obtiene un tren de pulsos como se puede observar en la figura 2.8, bajo los
siguientes parámetros de medición seleccionados en un osciloscopio:
Voltios/Div: 2V
Time/Div: 100ns
Figura 2.8

_______________________________________________________________________________________
55
La lectura de la frecuencia y período en este caso sería la siguiente:
Frecuencia: 3,999 Mhz
Período: 250,013 ns
El oscilador externo en modo RC resulta ser el más sencillo de todos y por ende el más
económico. Su configuración lo hace menos preciso debido a que existe una tolerancia de
error en sus componentes, sin olvidar también que la temperatura puede afectar la
operación de este tipo de oscilador.
Los valores recomendados para este oscilador son los siguientes:
5 Kohm
C1 > 20 pF
Figura 2.9

_______________________________________________________________________________________
56
2.3.- Circuito de Reset: El Pin denominado MCLR (Master Clear), siempre debe ser tomado
en cuenta cuando se diseña un circuito con microcontroladores PIC. A través de este Pin se
podrá reiniciar el dispositivo, si a éste se le aplica un nivel lógico bajo (0V), por lo tanto
resulta importante destacar que para que un programa cargado en un microcontrolador se
mantenga en ejecución, el Pin MCLR debe estar siempre en un nivel lógico alto (5V).
Si deseamos tener control externo del reset de un microcontrolador PIC, debemos
considerar el circuito de la figura 2.10:
Figura 2.10
Este circuito permite reiniciar el microcontrolador cada vez que el pulsador de “Reset” es
presionado.

_______________________________________________________________________________________
57
2.4.- Consideraciones técnicas de diseño.
A continuación veremos algunos circuitos básicos que deben ser tomados en cuenta para el
desarrollo de prácticas con microcontroladores PIC. Estos circuitos son muy útiles cuando
deseamos visualizar el resultado de una acción programada en el microcontrolador.
2.4.1.- Estado Lógico de un pin I/O.
Una manera muy sencilla de ver el estado lógico de un pin configurado como salida en
cualquiera de los puertos de microcontrolador es a través del uso de Leds, como se observa
en los circuitos de la figura 3.11.
En el circuito, el Led “D1” se iluminará solo cuando el estado lógico del pin de salida del
puerto (RB1) sea igual a “1”, es decir, 5 voltios.
El Led “D2” se iluminará solo cuando el estado lógico de la salida del puerto (RB0) sea igual
a “0”, es decir, 0 voltios.
Figura 2.11
Esto significa que si deseamos realizar un programa en mikroBasic encargado de cambiar el
estado lógico de un pin específico, en cualquiera de los puertos de un microcontrolador, una
forma “básica” de visualizar este cambio es a través del uso de Leds.

_______________________________________________________________________________________
58
2.4.2.- Lectura de un estado lógico en un pin I/O:
El microcontrolador también nos permite capturar datos o señales externas para luego ser
procesadas y convertidas en respuestas que pueden definir una acción específica en
nuestros circuitos de prueba. Un ejemplo común podría ser el uso de un pulsador para hacer
destellar un led cada vez que éste sea presionado.
Si deseamos introducir un nivel lógico bajo (0V), o alto (5V), a una de las entradas de un
microcontrolador a través de un pulsador, podríamos considerar los circuitos de la figura
2.12, los cuales nos proporcionan dos formas diferentes de hacerlo:
Figura 2.12
El primer circuito en la figura 2.12 mantiene un nivel lógico alto (5V) mientras el pulsador
permanece abierto. Al presionar el pulsador, el nivel lógico en el pin I/O del puerto pasa a
ser bajo (0V).
El segundo circuito de la figura 2.12 mantiene un nivel lógico bajo (0V) mientras el pulsador
permanece abierto. Al presionar el pulsador, el nivel lógico en el pin I/O del puerto pasa a
ser alto (5V).

_______________________________________________________________________________________
59
2.4.3.- El Opto-acoplador como dispositivo de enlace:
El opto-acoplador es un componente muy útil cuando se requiere acoplar circuitos
electrónicos digitales con etapas de manejo de potencia o con otros circuitos.
Este componente en una de sus versiones, se compone básicamente de un diodo LED el
cual se encarga de iluminar un fototransistor, para que éste conduzca corriente a través del
colector.
Figura 2.13
En la configuración de la figura 2.13, cuando en el pin I/O aplicamos un 1 lógico (5V), el LED
del opto-acoplador enciende y el fototransistor conduce la corriente a tierra; por lo tanto, en
la salida tendremos un 0 lógico (0V).
Si apagamos el LED, el transistor no conduce, de tal manera que en la salida tendremos un
1 lógico (5V).
En la configuración de la figura 2.14, cuando en el pin I/O aplicamos un 1 lógico (5V), el LED
del opto-acoplador enciende y el fototransistor conduce para poner en la salida un 1 lógico
(5V). Mientras haya un 0 lógico en la entrada, el fototransistor permanecerá abierto entre el
emisor y colector, dando como resultado un 0 lógico (0V) en la salida.

_______________________________________________________________________________________
60
Figura 2.14
Una configuración muy común para el control de dispositivos de potencia como motores
eléctricos, luces incandescentes, solenoides, etc., se puede ver en la figura 2.15, la cual se
basa en cualquiera de los dos circuitos antes mencionados (figura 2.13 y figura2.14), en la
cual se ha incluido un relé a través del cual circulará la corriente necesaria entre sus
contactos, para hacer funcionar cualquiera de estos dispositivos de potencia.
Figura 2.15

_______________________________________________________________________________________
61
2.4.4.- Fuente de poder, 5Vdc / 3.3Vdc:
En caso de no disponer de una fuente de poder regulada, proponemos la construcción de un
diseño sencillo que podemos implementar en todos los proyectos propuestos. En la figura
2.16 se puede observar el diseño de una fuente regulada con salidas de voltaje de +5 Vdc y
+3.3 Vdc:
Figura 2.16

_______________________________________________________________________________________
62
2.5.- Configuración de Puertos como Entrada o Salida en un microcontrolador PIC.
Como los pines de los puertos pueden ser configurados como “entradas” o como “salidas”,
es importante tomar en cuenta los registros de configuración de puertos, los cuales para el
caso específico del PIC16F877 son cinco:
TrisA (registro de configuración I/O del puerto A), es un registro de 8 bits, encargado de
determinar cual de los pines del puerto “A” será “entrada” o “salida”. Los tres Bits más
significativos de este registro no se encuentran implementados para este modelo de
microcontrolador, como se puede observar en el diagrama de pines del dispositivo (figura
2.17). En este caso, el puerto “A” solo cuenta con 5 pines I/O (RA0, RA1, RA2, RA3 y RA4).
Para determinar si uno de los pines de un puerto será “entrada” o “salida”, es importante
conocer la siguiente regla, la cual aplica para todos los modelos de microcontroladores PIC
en los cuales estaremos trabajando:
Si configuramos un Bit de un registro TRIS con un “1”, el pin del puerto
correspondiente a este Bit se comportará como una “entrada”.
Si configuramos un Bit de un registro TRIS con un “0”, el pin del puerto
correspondiente a este Bit se comportará como una “salida”.
Esto significa que si deseáramos configurar el Pin RA0 del puerto “A” como una “salida”,
tendremos entonces que poner un “0” en el Bit 0 del registro “TRISA”
Un ejemplo de configuración de los pines I/O del puerto A es el siguiente:
1 1 1 1 0
RA4 RA3 RA2 RA1 RA0
Registro TrisA
Figura 2.17
Al ver la figura 2.17, se puede observar que el pin RA0 ha sido configurado como salida y el
resto de los pines como entrada.
En mikroBasic, expresar este paso en forma de código es muy sencillo:
TrisA = %11110 (“%” para expresar la configuración en Binario), ó:
TrisA = $1E (”$” para expresar la configuración en Hexadecimal)
Bit menos
significativo

_______________________________________________________________________________________
63
Esto significa que el puerto A se comportará de la siguiente forma:
RA0 = salida.
RA1 a RA4 = entradas.
TrisB, es un registro de 8 bits en el cual se configuran los pines del puerto B, ya sea como
entrada o como salida, por ejemplo:
1 1 1 1 1 1 1 0
RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0
Registro TrisB
Figura 2.18
1 = Entrada (Al configurar un bit del registro TrisB en “1”, éste se comporta como entrada).
0 = Salida (Al configurar un bit del registro TrisB en “0”, éste se comporta como salida).
Para el caso particular del puerto B, se puede observar que el pin RB0 ha sido configurado
como salida en este ejemplo, y el resto de los pines como entrada.
“Consideramos importante configurar los pines que no estarán en uso como entrada, ya que
de esta forma podemos evitar daños en el hardware interno del microcontrolador en caso de
una conexión errónea al experimentar con éste en un tablero de pruebas.”
La configuración en mikroBasic en forma de código de programa en este caso sería:
TrisB = %11111110 (si se desea hacer la notación en binario), ó:
TrisB = $FE (si se desea hacer la notación en hexadecimal)
En este caso podemos determinar que el puerto “B” se comportará de la siguiente forma:
RB0 = Salida.
RB1 a RB7 = Entradas.
El mismo caso aplica para los registros de configuración de los puertos C, D y E. Sus
registros de configuración TRISC, TRISD y TRISE deberán ser siempre configurados para
determinar su función dentro de un proyecto electrónico.
Bit menos
significativo

_______________________________________________________________________________________
64
2.6.- Primeros ejemplos de programación en mikroBasic:
2.6.1.- Ejemplo de programación #1: Un ejemplo sencillo para determinar que hemos
iniciado de forma correcta todo lo referente a la configuración de un nuevo proyecto en
mikroBasic, es intentar realizar el encendido de uno o dos Leds a través de uno de los
puertos disponibles en el microcontrolador. Normalmente los pasos que vamos a realizar
para lograr este objetivo son los pasos básicos para realizar el resto de nuestros proyectos.
Estos pasos serán descritos a continuación y el programa para el encendido de dos Leds
estará basado en el diagrama esquemático de la figura 2.19.
Figura 2.19
Dos puntos importantes a considerar sobre este diagrama esquemático son:
El Led “D1” tiene su “ánodo” conectado al pin RB1 del puerto “B”, por lo tanto el Led
sólo encenderá cuando RB1 = 1.
El Led “D2” tiene su “cátodo” conectado al pin RB0 del puerto “B”, por lo tanto el Led
sólo encenderá cuando RB0 = 0

_______________________________________________________________________________________
65
Empecemos con la creación de un nuevo proyecto, siguiendo los pasos comentados en la
sección “Crear un nuevo proyecto en mikroBasic”.
Una vez creado el proyecto podremos ver en el entorno de desarrollo integrado de
mikroBasic la siguiente ventana de programación:
Figura 2.20
Nótese que en la ventana de programación mikroBasic ha generado automáticamente una
pequeña estructura de programa que nos servirá de guía para comenzar a programar. En
este caso, lo primero que vamos a agregar será la línea de configuración del puerto “B”, ya
que en él hemos conectado los Leds que deseamos encender. Para determinar la palabra
de configuración del registro TRISB, veamos la siguiente figura:
1 1 1 1 1 1 0 0
RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0
Registro TrisB
Figura 2.21

_______________________________________________________________________________________
66
TRISB = %11111100
Agregamos esta línea en la estructura del programa:
program Ejemplo1
' Area de declaración.
main: ' Programa Principal
TRISB = %11111100 ' Configuración del Puerto "B"
End.
Este paso se verá de la siguiente manera en la pantalla de nuestro PC:
Figura 2.22
El siguiente paso será hacer que los Leds enciendan. Para esto es posible especificar el
estado de un pin determinado del puerto “B” de la siguiente forma:
Para referirnos al Pin RB0: PortB.0 = (estado deseado del pin).
Para referirnos al Pin RB1: PortB.1 = (estado deseado del pin).

_______________________________________________________________________________________
67
Veamos:
program Ejemplo1
PORTB.0 = 1 ' El Led D2 enciende con un "0".
PORTB.1 = 1 ' El Led D1 enciende con un "1".
End.
Figura 2.23
Por último y para verificar que todo funciona según lo esperado, compilamos el programa a
través del acceso directo “Build” en la barra de herramientas:
Build
Si el programa no tiene errores, podremos ver en la ventana de errores que el resultado de
compilar el programa ha sido satisfactorio:

_______________________________________________________________________________________
68
Figura 2.24
Este resultado significa que el compilador ha creado además el archivo de extensión .hex el
cual utilizaremos para grabar el microcontrolador y de esta forma poder verificar el correcto
funcionamiento del programa sobre el circuito.

_______________________________________________________________________________________
69
2.6.2.- Ejemplo de programación #2: En este ejemplo hemos cambiado el conexionado de
los Leds y hemos incluido dos pulsadores. P1 está conectado entre Vcc y una resistencia
“Pull Down” al igual que P2. El estado de los pulsadores será medido a través de los pines
RD0 y RD1 del puerto “D”.
Esto significa que debemos configurar los pines RD0 y RD1 como entradas a través de
registro TRISD, para poder tomar lectura del estado en el cual se encuentran, de tal forma
que podamos tomar una decisión y generar una salida en los pines RB0 y RB1.
Es importante observar que cuando los dos pulsadores se encuentran normalmente
abiertos, el estado de los pines es el siguiente:
RD0 = 0
RD1 = 0
Al presionar cada pulsador, el estado en estos pines cambia:
RD0 = 1
RD1 = 1
Figura 2.25

_______________________________________________________________________________________
70
El objetivo del programa que haremos a continuación será encender los Leds de forma
individual asignando a cada uno de ellos un pulsador. Al encender uno de estos Leds, éste
deberá permanecer encendido durante 2 segundos.
El Led D1, enciende cuando presionamos el pulsador P1.
El Led D2, enciende cuando presionamos el pulsador P2.
Analicemos el siguiente programa leyendo detenidamente cada línea de código y sus
respectivos comentarios:
program Ejemplo2
main: ' Programa Principal.
TRISD = %11111111 ' Configuración del Puerto "D"
PORTB.0 = 0 ' Inicializamos el pin RB0, para asegurar que el
' el Led D1 esté apagado.
PORTB.1 = 0 ' Inicializamos el pin RB1, para asegurar que el
Pulsadores:
If PortD.0 = 1 Then ' Verificamos el estado del pulsador "P1".
GoSub Led1 ' Si P1 es presionado, llama a la subrutina "Led1".
End If
If PortD.1 = 1 Then ' Verificamos el estado del pulsador "P2".
End If
GoTo Pulsadores ' Salta a la etiqueta "Pulsadores" para iniciar el
' proceso de verificación de los pulsadores.
Led1:
PORTB.0 = 1 ' Enciende el Led D1, conectado en RB0
delay_ms(2000) ' Hace una pausa de 2 segundos o 2000 milisegundos.
PORTB.0 = 0 ' Apaga el Led D1.
Return ' Retorno del llamado Gosub.
Led2:
PORTB.1 = 1 ' Enciende el Led D2, conectado en RB1
PORTB.1 = 0 ' Apaga el Led D2.
End.
Para comprobar su correcto funcionamiento, compilamos el programa y grabamos el
microcontrolador PIC. Observe siempre la ventana de errores de mikroBasic; esta ventana
provee buena información en caso de errores de sintaxis en el cuerpo del programa.

_______________________________________________________________________________________
71
Si todo ha funcionado correctamente, pasaremos ahora a mejorar la estructura del programa
haciendo uso de “Alias”, a través de los cuales daremos nombres a los pines de los puertos
que estamos utilizando en el circuito. Es decir, en vez de dirigirnos a ellos como PortB.0,
PortB.1, PortD.0 y PortD.1, sustituiremos estos por los siguientes Alias:
El pin RB0 ó PortB.0 lo llamaremos “D1”
El pin RB1 ó PortB.1 lo llamaremos “D2”
El pin RD0 ó PortD.0 lo llamaremos “P1”
El pin RD1 ó PortD.1 lo llamaremos “P2”
Verifique estos cambios en el siguiente código de programa:
program Ejemplo2
Symbol D1 = PORTB.0 ' Alias del Pin RB0
Symbol P1 = PortD.0 ' Alias del Pin RD0
Symbol P2 = PortD.1 ' Alias del Pin RD1
D1 = 0 ' Inicializamos el pin RB0, para asegurar que el
Pulsadores:
If P1 = 1 Then ' Verificamos el estado del pulsador "P1".
End If
If P2 = 1 Then ' Verificamos el estado del pulsador "P2".
End If
Led1:
D1 = 1 ' Enciende el Led D1, conectado en RB0
D1 = 0 ' Apaga el Led D1.
Led2:
End.

_______________________________________________________________________________________
72
2.6.3.- Ejemplo de programación #3: En este ejemplo haremos uso de la librería “Button”
de mikroBasic.
“Button” permite eliminar rebotes en pulsadores o interruptores, evitando así errores de
lectura que pueden generar mal funcionamiento de nuestros diseños.
La sintaxis de esta rutina es la siguiente:
Button(Puerto, Pin, Tiempo, Estado Activo)
Puerto: En este campo debemos especificar en cual de los puertos estaremos
conectando el pulsador o interruptor.
Pin: Este campo representa un pin específico del puerto que estaremos utilizando
para tomar lectura de un pulsador o interruptor.
Tiempo: Este campo es un período de anti-rebote en milisegundos. Este valor puede
variar entre 1 y 255. Cada unidad de tiempo mide aproximadamente 0.98
milisegundos, por lo tanto, si usamos el valor máximo para el período de anti-rebote,
es decir “255”, el tiempo de anti-rebote será de 250 milisegundos.
Estado Activo: Este parámetro puede ser cero (0) ó uno (1). A través de este campo
podemos definir si el pulsador o interruptor estará activo con un 0 lógico o con un 1
lógico.
Esta rutina también devuelve un resultado (255), si el pulsador o interruptor han estado en
un estado activo durante el tiempo especificado. En caso contrario, devuelve un cero (0).
Veamos un ejemplo práctico, basado en el ejemplo de programación #2.
program Ejemplo3
Dim Estado As Byte
Pulsadores:
Estado = Button(PortD, 0, 255, 1) ' Verificamos si P1 fue presionado, estado activo = 1.
If Estado = 255 Then ' Verificamos el resultado de la rutina “Button”.
End If

_______________________________________________________________________________________
73
Estado = Button(PortD, 1, 255, 1) ' Verificamos si P2 fue presionado, estado activo = 1.
If Estado = 255 Then ' Verificamos el resultado de la rutina “Button”.
End If
Led1:
delay_ms(1000) ' Hace una pausa de 1 segundo o 1000 milisegundos.
Led2:
End.
Observando los cambios realizados en el programa, tenemos que:
Hemos eliminado los “Alias” de los pulsadores.
Declaramos la variable “Estado” tipo Byte, para almacenar el estado de la rutina
“Button”. Si un pulsador permanece activo durante el tiempo de anti-rebote
especificado, la rutina “Button” nos devolverá el valor “255” el cual es almacenado en
la variable “Estado”.
Evaluamos el contenido de la variable “Estado” y seguidamente tomamos una
decisión con respecto al puerto de salida.
Para comprender mejor el funcionamiento de esta rutina, analizaremos la señal generada
por el pulsador y la salida generada por el microcontrolador para encender o apagar los
Leds.
En la siguiente imagen, hemos representado el estado del pulsador P1 en el canal “Rojo” del
osciloscopio, y el Led D1 en el canal “Verde” del osciloscopio.
Cuando activamos momentáneamente el pulsador P1, pero no lo mantenemos activo el
tiempo suficiente para cumplir con el período de tiempo de anti-rebote, ocurre que el valor
devuelto por la rutina “Button” es igual a cero (0). En este caso, podremos observar que en
la salida correspondiente al Led D1 no hay actividad alguna, como lo demuestra la figura
2.26.

_______________________________________________________________________________________
74
Figura 2.26
Si mantenemos el pulsador P1 activo el tiempo suficiente para vencer el tiempo de anti-
rebote, la rutina “Button” devuelve el valor “255”. Entonces podremos generar la salida
deseada en el pin del puerto correspondiente al Led D1 (Canal Verde):
Figura 2.27

_______________________________________________________________________________________
75
El canal verde de la figura 2.27 muestra un pulso de 1 segundo de duración, generado
desde la subrutina “Led1” del programa.
Si medimos con el osciloscopio el tiempo de anti-rebote, podremos observar que es igual o
aproximado a 250 milisegundos:
Figura 2.28
Este tiempo es medido desde que inicia el pulso en el canal rojo del osciloscopio, hasta el
inicio del pulso del canal verde. En este ejemplo, el tiempo medido en el osciloscopio ha
dado como resultado un tiempo de antirrobote igual a 250 milisegundos.
También es posible utilizar la rutina Button de la siguiente manera:
program Ejemplo_3_1
Pulsadores:
If Button(PortD, 0, 255, 1) Then ' Verificamos si P1 fue presionado, estado activo = 1.
Tiempo Anti-rebote

_______________________________________________________________________________________
76
End If
If Button(PortD, 1, 255, 1) Then ' Verificamos si P2 fue presionado, estado activo = 1.
End If
Led1:
Led2:
End.
Observe que hemos eliminado la variable “Estado” en el programa y hemos simplificado la
subrutina “Pulsadores”.

_______________________________________________________________________________________
77
Capitulo III. Pantallas LCD y GLCD
A continuación estudiaremos las librerías encargadas del control de pantallas LCD y GLCD
de mikroBasic PRO a través de ejemplos claros y de fácil entendimiento.
Pantalla LCD Alfanumérica Pantalla Gráfica GLCD
3.1.- Pantallas LCD, estudio de la librería LCD de mikroBasic.
El primer paso siempre será tener un diagrama de pines de la pantalla LCD y a su vez definir
de una vez el conexionado con los puertos del microcontrolador, incluso antes de realizar
cualquier programación. Al hacer esto, entonces tendremos una base sobre la cual trabajar
el programa, en el cual debemos definir los pines de conexión de la misma, de manera que
el microcontrolador sepa donde dirigir la información y las instrucciones que controlarán
estos módulos.
3.1.1.- Identificación de los pines de una pantalla LCD: Veamos a continuación la
descripción de cada uno de los pines de una pantalla LCD:
Figura 3.1. Pinout de un módulo LCD con
conexión a Vcc, Gnd y Control de contraste.
Pin 1, 2 y 3: como se puede observar en la figura 6.4, en la mayoría de las pantallas LCD, el
Pin No. 1 y 2 corresponden a la alimentación de la pantalla, GND y Vcc, donde el voltaje

_______________________________________________________________________________________
78
máximo comúnmente soportado es de 5 Vdc. El Pin No.3 corresponde al control de
contraste de la pantalla.
Pin 4: "RS" (trabaja paralelamente al Bus de datos del modulo LCD, Pines 7 al 14, es decir,
cuando RS es cero, el dato presente en el bus corresponde a un registro de control o
instrucción, pero cuando RS es uno, el dato presente en el bus corresponde a un registro de
datos o caracter alfanumérico.
Pin 5: "R/W" (Read/Write), este pin es utilizado para leer un dato desde la pantalla LCD o
para escribir un dato en la pantalla LCD. Si R/W = 0, esta condición indica que podemos
escribir un dato en la pantalla. Si R/W = 1, esta condición nos permite leer un dato desde la
pantalla LCD.
Pin 6: "E" (Enable), este es el pin de habilitación, es decir, si E = 0 el módulo LCD se
encuentra inhabilitado para recibir datos, pero si E = 1, el módulo LCD se encuentra
habilitado para trabajar, de tal manera que podemos escribir o leer desde el modulo LCD.
Pin 7 al14: "Bus de Datos”, el Pin 7 hasta el Pin 14 representan 8 líneas que se utilizan para
colocar el dato que representa una instrucción para el modulo LCD o un carácter
alfanumérico.
Pin 15-16: "BackLight", en muchos modelos de LCD, los pines 15 y 16 son respectivamente
el “Ánodo” y el “Cátodo”, aunque se pueden encontrar en el mercado modelos de pantallas
LCD donde esta condición es configurable desde la parte posterior del circuito impreso a
través de “Jumpers”, o conexiones donde podemos invertir los Pines, de manera tal que el
Pin 15 sea el “Cátodo” y el Pin 16 el “Ánodo”, como se muestra en la figura 3.2.
Figura 3.2
3.1.2.- Conexión y configuración de una pantalla LCD: Una pantalla LCD puede ser
conectada a un microcontrolador utilizando los ocho bits del bus de datos (D0 a D7) o
solamente los cuatro bits mas significativos del bus de datos (D4 a D7). Al emplear los ocho
bits, estos deberán estar conectados en un solo puerto y nunca en puertos diferentes. Si
deseamos trabajar solo con los cuatro bits más significativos del bus, estos deberán ser
conectados en los cuatro bits menos significativos de un puerto o en los cuatro bits más
significativos del puerto seleccionado.

_______________________________________________________________________________________
79
Los pines E (Pin 6) y RS (Pin 4) pueden estar conectados en cualquier puerto del
microcontrolador. Por último, el Pin R/W deberá estar conectado a tierra (GND) para indicar
a la pantalla LCD que estaremos escribiendo en ella.
Un dato interesante resulta ser el hecho de que las pantallas LCD pueden ser controladas
utilizando dos configuraciones distintas para el bus de datos:
La primera configuración es a 4 bits de datos, lo cual reduce a la mitad la cantidad de
pines a ser utilizados en un puerto de un microcontrolador PIC. MikroBasic cuenta con
una librería para el control de pantallas LCD a 4 bits, denominada “LCD Library”.
La segunda configuración posible es a 8 bits de datos, lo cual requiere que conectemos
todos los pines del bus (D0 hasta D7 en la pantalla LCD), en uno de los puertos
disponibles de un microcontrolador PIC. Esta configuración será descartada en esta
ocasión, ya que la idea es optimizar los recursos disponibles en nuestro hardware
utilizando la menor cantidad de puertos en nuestros circuitos.
Comenzaremos a realizar las prácticas basadas en la configuración de 4 bits, como se
sugiere en el siguiente diagrama esquemático. Diagrama de conexión entre un módulo LCD
y un PIC16F877 en configuración de 4 bits:
Figura 3.3

_______________________________________________________________________________________
80
El primer punto importante será aprender a inicializar una pantalla LCD con mikroBasic. El
primer paso que debemos realizar será especificar en el programa de que manera han sido
conectados los pines de control y datos de la pantalla LCD en el puerto elegido del
microcontrolador.
Basados en el diagrama esquemático de la figura 3.3, la configuración de pines se realiza de
la siguiente manera:
' Configuración de los pines de la LCD
Dim LCD_RS As sbit At RB4_bit
LCD_EN As sbit At RB5_bit
LCD_D4 As sbit At RB0_bit
LCD_RS_Direction As sbit At TRISB4_bit
LCD_EN_Direction As sbit At TRISB5_bit
LCD_D4_Direction As sbit At TRISB0_bit
' Fin de la configuración de conexiones
La configuración anterior puede ser interpretada de la siguiente manera:
Pin de Control en la LCD: RS PortB.4
Pin de Control en la LCD: E PortB.5
Pin de datos en la LCD: D4 PortB.0
3.1.3.- LCD_Init()
Esta rutina es necesaria para inicializar un módulo LCD. Normalmente se ubica al inicio del
programa, después de la etiqueta de inicio y no en la zona de declaración de variables o
configuración de pines de la pantalla.
Ejemplo:
LCD_Init()

_______________________________________________________________________________________
81
3.1.4.- Lcd_Cmd(comando)
Esta rutina es importante para el control de una pantalla LCD, la cual puede facilitar la
programación de ciertas funciones importantes.
En el campo “comando” de la rutina, podemos especificar algunas funciones las cuales se
describen en la siguiente tabla:
Comando LCD Propósito
_Lcd_First_Row Mueve el cursor a la primera columna
_Lcd_Second_Row Mueve el cursor a la segunda columna
_Lcd_Third_Row Mueve el cursor a la tercera columna
_Lcd_Fourth_Row Mueve el cursor a la cuarta columna
_Lcd_Clear Limpia la pantalla LCD
_Lcd_Return_Home Cursor a la posición de inicio
_Lcd_Cursor_Off Apaga el cursor en la pantalla LCD
_Lcd_Underline_On Cursor “Underline” encendido
_Lcd_Blink_Cursor_On Activa la intermitencia en el cursor
_Lcd_Move_Cursor_Left Mueve el cursor a la izquierda sin alterar el contenido de la RAM
_Lcd_Move_Cursor_Right Mueve el cursor a la derecha sin alterar el contenido de la RAM
_Lcd_Turn_On Activa o enciende la pantalla LCD
_Lcd_Turn_Off Desactiva o apaga la pantalla LCD
_Lcd_Shift_Left Desplazamiento a la izquierda sin alterar el contenido de la RAM
_Lcd_Shift_Right Desplazamiento a la derecha sin alterar el contenido de la RAM
Figura 3.4
Tal y como esta especificado en la tabla anterior, es posible realizar fácilmente acciones
como mover el cursor o limpiar la pantalla entre otras como se demuestra en el próximo
ejercicio, pero antes veamos otras rutinas importantes.
3.1.5.- Lcd_Out(Fila, Columna, Texto)
La rutina Lcd_Out() nos permite escribir en una posición específica de la pantalla LCD, su
estructura es muy sencilla y se ve como sigue a continuación:
Ejemplo:
Lcd_Out(1, 4, “mikroBasic”)
Este ejemplo se interpreta de la siguiente forma: Escribir la palabra “mikroBasic” (sin incluir
las comillas) en la línea 1 de la pantalla, empezando en la columna 4.
Si deseamos escribir en la segunda línea de la pantalla, pero a partir de la primera columna,
entonces el cambio en la rutina sería el siguiente:
Lcd_Out(2, 1, “mikroBasic”)

_______________________________________________________________________________________
82
3.1.5.1.- Ejemplo de programación #4: Veamos a continuación un ejemplo de
programación, basados en el diagrama esquemático 3.3, y utilizando las rutinas hasta ahora
comentadas:
program Proyecto_LCD_1
' Sección de Declaración
LCD_Init()
LCD_Cmd(_LCD_CLEAR) ' Limpia la pantalla LCD
LCD_Cmd(_LCD_CURSOR_OFF) ' Apaga el cursor en la pantalla
Delay_ms(1000) ' Retardo de 1 segundo
LCD_Out(1,4,"mikroBasic") ' Imprime en la linea 1 y columna 4
End.
El resultado de este ejemplo se puede observar en la figura 3.5.
Figura 3.5
Antes de compilar y analizar el programa, es importante verificar si la librería LCD ha sido
incluida al crear el proyecto. Esto lo sabremos fácilmente desplegando la pestaña del
administrador de librerías, en la cual deberán estar seleccionadas las librerías
correspondientes a este ejercicio:

_______________________________________________________________________________________
83
Figura 3.6
Observe que cuando la librería correspondiente no ha sido incluida, las rutinas de nuestros
programas son subrayadas por una línea roja ondulada indicando que no han sido
reconocidas las rutinas en el programa.

_______________________________________________________________________________________
84
La siguiente imagen demuestra como se debe ver nuestro programa para que no se generen
errores al compilar:
Figura 3.7
Si observamos cada línea de programación, y analizamos cada una de ellas, tenemos que:
El primer paso ha sido configurar los pines de control y datos de la pantalla LCD en el
formato anteriormente especificado con respecto al puerto elegido en el
microcontrolador.
Inicializamos la pantalla LCD a través de la rutina LCD_Init().
Limpiamos la pantalla LCD con el comando correspondiente, según la tabla de la
figura 3.4.
Apagamos el cursor en la pantalla.
Hacemos una pausa de 1000 milisegundos o 1 segundo.
Escribimos la palabra “mikroBasic” en la línea 1, columna 4 de la pantalla LCD.

_______________________________________________________________________________________
85
3.1.5.2.- Ejemplo de programación #5:
Veamos otro ejemplo utilizando otros comandos de la tabla:
Dim I As Byte
LCD_Init()
LCD_Out(1,4,"mikroBasic") ' Imprime en la linea 1 y columna 4
LCD_Cmd(_Lcd_Blink_Cursor_On) ' Encendemos el Cursor en la Pantalla LCD
For I = 0 To 10 ' Lazo For-Next para realizar 10 repeticiones
' del siguiente comando:
LCD_Cmd(_Lcd_Move_Cursor_Left) ' Mueve el cursor un espacio a la Izquierda
Delay_ms(300) ' Retardo de 300 milisegundos
Next I
LCD_Cmd(_Lcd_Move_Cursor_Right) ' Mueve el cursor un espacio a la derecha
Next I
Lcd_Cmd(_Lcd_Turn_Off) ' Apagamos la pantalla LCD
delay_ms(2000) ' Retardo de 2 segundos
GoTo main ' Salto a la etiqueta “main”
End.
A diferencia del programa en el primer ejercicio, ahora hemos activado el cursor en modo
intermitente, para luego hacer una pausa de tres segundos y empezar a desplazar el mismo
diez posiciones hacia la izquierda y luego diez posiciones a la derecha. Para poder ver el
movimiento del cursor se ha incluido una pequeña pausa de 300 milisegundos. Por último

_______________________________________________________________________________________
86
apagamos la pantalla LCD a través del comando _Lcd_Turn_Off, esperamos 2 segundos y
comenzamos el proceso haciendo un salto a la etiqueta “main”.
También podemos desplazar el contenido impreso en la pantalla LCD hacia la izquierda o
hacia la derecha, utilizando los dos últimos comandos de la figura 3.4:
_Lcd_Shift_Left
_Lcd_Shift_Right
3.1.5.3.- Ejemplo de programación #5.1: Verifique el siguiente programa y lea
detenidamente sus comentarios. Rápidamente podrá notar los cambios con respecto al
ejemplo anterior:
Dim I As Byte
main:
LCD_Init() ' Inicializamos la pantalla LCD
LCD_Out(1,4,"mikroBasic") ' Imprime en la fila 1 y columna 4
LCD_Cmd(_Lcd_Blink_Cursor_On)
LCD_Cmd(_Lcd_Shift_Left) ' desplaza el contenido hacia la Izquierda
Next I
LCD_Cmd(_Lcd_Shift_Right) ' desplaza el contenido hacia la derecha

_______________________________________________________________________________________
87
Next I
Lcd_Cmd(_Lcd_Turn_Off) ' Apagamos la pantalla LCD
delay_ms(2000) ' Retardo de 2 segundos
GoTo main ' Salto a la etiqueta main
End.
3.1.6.- Lcd_Out_Cp(“caracteres”)
Esta es otra rutina útil en el manejo de la pantalla LCD. La función de esta rutina es escribir
en la pantalla LCD los caracteres especificados en la posición en la cual ha quedado el
cursor.
main:
LCD_Cmd(_LCD_Clear) ' Limpia la pantalla LCD
LCD_Cmd(_LCD_Cursor_Off) ' Apaga el cursor en la pantalla
LCD_Out(1,3,"mikro") ' Imprime en la fila 1 y columna 3
Lcd_Out_Cp("Basic") ' Imprime la palabra "Basic" en la posición
' en la cual quedó el cursor
End.

_______________________________________________________________________________________
88
Figura 3.8
Otras dos rutinas de mikroBasic para el manejo de pantallas LCD son las que se muestran a
continuación:
3.1.7.- Lcd_Chr()
Lcd_Chr(fila, columna, “caracter”): Esta rutina imprime un solo caracter en la fila y columna
especificada.
3.1.8.- Lcd_Chr_Cp()
Lcd_Chr_Cp(“caracter”): Esta rutina imprime un caracter en la posición en la cual ha
quedado el cursor.
3.1.8.1.- Ejemplo de programación #7: El siguiente ejercicio, imprime en la fila 1, columna
8 de la pantalla LCD el caracter “@”.
main:
LCD_Init() ' Inicializa la pantalla LCD
LCD_Chr(1,8,"@") ' Imprime un caracter en la fila 1 y columna 8
Lcd_Chr_Cp("%") ' Impreime el caracter en la posición actual del cursor
End.

_______________________________________________________________________________________
89
El resultado será el siguiente:
Figura 3.9
3.2.- Parámetros de rutinas cargados en variables:
Los parámetros de las rutinas son los campos que debemos completar dentro de ellas, para
obtener un resultado específico según la función para la cual ha sido creada. Por ejemplo,
los parámetros dentro de la rutina Lcd_Out(fila, columna, texto) los cuales hemos
estudiado anteriormente, pueden ser cargados en forma de “variables”, y el tipo de variable
a definir dependerá de sus funciones específicas dentro de la misma. Para visualizar este
concepto de forma clara, supongamos que deseamos imprimir en la primera línea de la
pantalla e iniciando en la primera columna la palabra “mikro”. La forma más directa y sencilla
de hacer esto sería:
LCD_Out(1,1,"mikro") ' Imprime en la linea 1 y columna 3
Pero en algunos casos, será necesario controlar estos parámetros a través de variables las
cuales pueden cambiar su valor o contenido según sea necesario para la aplicación que
estemos desarrollando.
Dim fila As Byte ' declaración de la variable "fila" tipo byte
columna As Byte ' declaración de la variable "columna" tipo byte
texto As String[10] ' declaración de la variable "texto" tipo string
main:
fila = 1
columna = 1
texto = “mikro Basic”
.
.
Lcd_Out(fila, columna, texto)
.
.
End.

_______________________________________________________________________________________
90
3.2.1.- Ejemplo de programación #8:
main:
fila = 1 ' cargamos la variable con el numero de la fila
columna = 3 ' cargamos la variable con el numero de la columna
LCD_Out(fila,columna,"mikro Basic") ' Imprime en la fila 1, columna 3
Lcd_Out_Cp("Basic") ' Imprime la palabra "Basic" en la posición
End.
Se puede observar en el programa anterior que hemos sustituido los valores en la rutina
LCD_Out(1, 3, “mikro Basic”) por sus respectivas variables, declaradas al inicio del
programa, y a las cuales les dimos el nombre de “fila” y “columna”.
Veamos otro ejemplo de programación en el cual se carga el texto que se desea imprimir en
dos variables separadas:

_______________________________________________________________________________________
91
texto1 As string[8] ' Variable tipo String "texto1"
main:
fila = 1 ' cargamos la variable con el numero de la fila
columna = 3 ' cargamos la variable con el numero de la columna
texto1 = "mikro" ' cargamos el texto "mikro" en la variable
texto2 = "Basic" ' cargamos el texto "Basic" en la variable
LCD_Out(fila,columna,texto1) ' Imprime en la fila 1, columna 3
Lcd_Out_Cp(texto2) ' Imprime la palabra "Basic" en la posición
End.
Figura 3.10

_______________________________________________________________________________________
92
3.3.- Imprimir el contenido de una variable numérica en una pantalla LCD:
Es muy importante tomar en cuenta que para visualizar el contenido de una variable
numérica a través de la pantalla LCD, debemos seguir un procedimiento sencillo el cual
involucra una de las librerías de mikroBasic denominada “Conversions”.
Esta librería contiene varias rutinas a través de las cuales podremos convertir el contenido
de una variable en un string de datos, los cuales podrán ser presentados en la pantalla con
la ayuda de la rutina Lcd_Out(), tal y como lo estudiamos en el ejemplo de programación #9.
Para comprender de forma clara este punto, supongamos que se desea visualizar el
contenido numérico de las siguientes variables en la pantalla LCD:
Dim Var_1 As Byte
Var_2 As Word
Var_3 As Float
.
.
Var_1 = 127
Var_2 = 15000
Var_3 = 3.1416
.
.
End.
Observe que la primera variable (numero_1) es del tipo “Byte” y tiene un valor cargado igual
a 127. Si intentamos imprimir en la pantalla LCD el contenido de esta variable a través del
campo “texto” de la rutina Lcd_out(), el resultado será un error de sintaxis a la hora de
compilar el programa:
Error Incompatible types (“complex type” to “simples type”)
Esto debido a que la rutina Lcd_Out() sólo es capáz de imprimir variables tipo “cadena” o
“string”. En este caso, la solución se extrae de la librería “Conversions” de mikroBasic, la
cual posee una rutina específica para cada caso de conversión de variables según su tipo de
declaración:
ByteToStr(“variable tipo Byte a convertir”, “variable tipo string”): convierte una
variable tipo “Byte” en una cadena de caracteres los cuales serán almacenados en
una variable tipo “string” previamente declarada.
WordToStr(“variable tipo Word a convertir”, “variable tipo string”): convierte una
variable tipo “Word” en una cadena de caracteres los cuales serán almacenados en

_______________________________________________________________________________________
93
FloatToStr(“variable tipo Float a convertir”, “variable tipo string”): convierte una
variable tipo “Float” en una cadena de caracteres los cuales serán almacenados en
IntToStr(“variable tipo Integer a convertir”, “variable tipo string”): convierte una
variable tipo “Integer” en una cadena de caracteres los cuales serán almacenados en
Veamos a continuación un ejemplo de conversión de datos almacenados en tres diferentes
tipos de variables, Byte, Word y Float.
Dim Var_1 As Byte ' Declaramos la primera variable tipo Byte.
Var_2 As Word ' Declaramos la primera variable tipo Word.
Var_3 As Float ' Declaramos la primera variable tipo Float.
Txt As String[10] ' Declaramos la primera variable tipo String.
main:
Var_1 = 127 ' Inicializamos la variable “Var_1”.
Var_2 = 15000 ' Inicializamos la variable “Var_2”.
Var_3 = 3.14159265 ' Inicializamos la variable “Var_3”.
Variables:
LCD_Init() ' Inicializamos la pantalla LCD.
LCD_Cmd(_LCD_Clear) ' Limpia la pantalla LCD.
LCD_Cmd(_LCD_Cursor_Off) ' Apaga el cursor en la pantalla.
Lcd_Out(1, 1, "Variable Byte: ") ' Imprime mensaje en la pantalla LCD.
ByteToStr(Var_1, Txt) ' Convierte el contenido de la variable.
LCD_Out(2, 7, Txt) ' Imprime en la fila 1, columna 1.
Delay_ms(2000) ' Retardo de 2 segundos.
Lcd_Out(1, 1, "Variable Word: ") ' Imprime mensaje en la pantalla LCD.
WordToStr(Var_2, Txt) ' Convierte el contenido de la variable.

_______________________________________________________________________________________
94
Lcd_Out(1, 1, "Variable Float: ") ' Imprime mensaje en la pantalla LCD.
FloatToStr(Var_3, Txt) ' Convierte el contenido de la variable.
GoTo Variables ' Salta a la etiqueta “Variables”.
End.
Para hacer un poco más interesante la tarea de mostrar datos en la pantalla LCD, vamos a
agregar un par de pulsadores normalmente abiertos en el puerto D del microcontrolador.
Específicamente en los puertos RD0 y RD1, los cuales debemos de configurar como
entrada, y los cuales cuentan además con una resistencia Pull Down de 10 kohm, como se
demuestra en el siguiente diagrama esquemático:
Figura 3.11
Para este ejemplo se ha realizado un programa que muestra el valor cargado en una
variable a la cual hemos denominado “Dato”, y la cual podrá ser incrementada al accionar el
pulsador “P1” conectado en RD0; el valor de esta variable también se podrá decrementar al
accionar el pulsador “P2” conectado en RD1.
Los puertos han sido configurados de la siguiente manera:
Puerto D: se configura como entrada ya que en los pines RD0 y RD1 estarán
conectados los pulsadores P1 y P2.

_______________________________________________________________________________________
95
Puerto B: se inicializa según la configuración de la pantalla LCD, la cual en este caso
se mantiene con respecto al diagrama esquemático 3.11.
La variable “dato” ha sido inicializada con un valor cargado igual a 25. Para aumentar o
disminuir este valor, simplemente se pregunta si en RD0 o en RD1 hay un cambio de estado
lógico. Debemos considerar que el estado lógico presente en ambos pines es cero (0)
cuando el pulsador está normalmente abierto, esto gracias a las resistencias Pull Down de
10kohm. Al presionar cualquiera de los dos pulsadores, el estado lógico de los pines pasa a
ser uno (1).
Adicionalmente se establecen dos condiciones en el planteamiento de este ejercicio que se
deben cumplir cuando la variable aumenta o disminuye su valor, fijando límites en los
extremos, es decir, un límite inferior igual a uno (1), y un límite superior igual a cincuenta
(50):
La primera condición al pulsar P1 para el incremento es: cuando la variable “dato” sea
igual a 51, actualizamos su valor a 50, de tal manera que el valor máximo a ser
mostrado en la pantalla sea igual a cincuenta, el cual es el límite superior fijado
propuesto en el planteamiento anterior.
La segunda condición al pulsar P2 para disminuir el valor cargado en la variable es:
cuando la variable “dato” sea igual a cero (0), actualizamos su valor a uno (1), de tal
manera que su valor mínimo a ser mostrado en la pantalla siempre sea igual a uno
(1), el cual es el límite inferior propuesto.
Dim texto1 As string[16] ' Variable tipo String "texto1"
txt As String[6] ' Variable de contenido temporal tipo String
dato As Byte ' Variable tipo Byte para cargar datos
TRISD = $FF ' Configuración del puerto C como entrada.
main:
dato = 25
texto1 = "P1 Suma P2 Resta" ' cargamos el texto en la variable
texto2 = "Dato = " ' cargamos el texto en la variable

_______________________________________________________________________________________
96
LCD_Out(1, 1,texto1) ' Imprime en la fila 1, columna 1
While true
ByteToStr(dato, txt) ' Convierte el valor numérico en String.
Lcd_Out(2, 8, txt) ' Imprime el contenido cargado en "txt" en la fila 2,
' columna 8.
While PortD.0 = 1 ' Verifica si la condición expresada se cumple,
' es decir, pregunta si RD0 fue presionado. Si
' RD0 no es igual a 1, significa que el pulsador P1 no
' ha sido presionado, por lo tanto no se ejecutan las
' instrucciones dentro de while-wend.
dato = dato + 1 ' Incrementa en una unidad el valor de la variable "dato"
delay_ms(300) ' Realiza una pausa de 300 milisegundos para evitar que
' el incremento de la variable sea muy acelerado mientras
' el pulsador P1 esté presionado.
ByteToStr(dato, txt)' Convierte el valor numérico en String.
' columna 8.
If dato = 51 Then ' Fijamos un límite superior (50) a la variable dato y se
' se interpreta asi: si dato es igual a 51, entonces
' volvemos a hacer a "dato" igual a 50:
dato = 50
End If
Wend
dato = dato - 1 ' Decrementa en una unidad el valor de la variable "dato"
' el decremento de la variable sea muy acelerado mientras
' columna 8.
If dato = 0 Then ' Fijamos un límite inferior (1) a la variable dato y se
dato = 1
End If
Wend
Wend
End.

_______________________________________________________________________________________
97
Al compilar y grabar este ejemplo en el microcontrolador, el resultado inicial será el que
vemos en la siguiente figura:
Figura 3.12
Se puede observar que no es necesario presionar ningún pulsador para que el dato inicial
de la variable (25) aparezca en pantalla. Este dato se presenta al iniciar el programa gracias
a que hemos programado las dos siguientes líneas de código justo antes de empezar a
preguntar por el estado de los pulsadores:
main:
.
.
.
While true
ByteToStr(dato, txt) ' Convierte el valor numérico en String.
' columna 8.
While PortD.0 = 1
.
.
.
Se observa además en el programa que estamos realizando una conversión de la variable
que almacena el dato, de byte a string, debido a que no podemos representar directamente
el contenido de una variable tipo byte como caracteres ASCII en la pantalla LCD.

_______________________________________________________________________________________
98
Es por esto que damos uso a la librería “Conversions” la cual deberá estar seleccionada en
la pestaña de librerías, como se muestra en la siguiente figura:
Figura 3.13
Lo siguiente será verificar si al presionar P1, la variable “dato” aumenta su valor:
dato = dato + 1 ' Incrementa en una unidad el valor de la variable "dato"
' el incremento de la variable sea muy acelerado mientras
' columna 8.

_______________________________________________________________________________________
99
If dato = 51 Then ' Fijamos un límite superior (50) a la variable dato y se
dato = 50
End If
Wend
En esta parte, debemos observar que todas estas instrucciones será ejecutadas sólo si
PortD.0 = 1. Entonces, al presionar P1, la condición en la instrucción “while” se cumple y el
microcontrolador pasa a ejecutar la siguiente línea en la cual incrementamos el valor de la
variable “dato” en una unidad.
Después tenemos un retardo de 300 milisegundos, con la finalidad de evitar que el
incremento en la variable sea muy acelerado mientras el pulsador P1 se encuentra
presionado.
Seguidamente reescribimos el nuevo valor de la variable en la pantalla LCD y verificamos si
este valor es mayor a 50.
El mismo procedimiento se cumple para el análisis del pulsador P2, el cual decrementa el
valor de la variable “dato”
En el siguiente proyecto nos hemos basado en el diagrama de la figura 3.11 para efectuar la
programación del microcontrolador.
La idea principal en este ejemplo, será mostrar un menú inicial en la pantalla LCD, tal y
como se observa a continuación:
Figura 3.14

_______________________________________________________________________________________
100
Al accionar el pulsador “P1”, se deberá mostrar el siguiente submenú (figura 3.15), el
cual deberá permanecer visible durante 5 segundos para luego retornar al menú
inicial:
Figura 3.15
Al accionar el pulsador “P2”, se deberá mostrar el siguiente submenú (figura 3.16), el
cual también deberá permanecer visible durante 5 segundos para luego retornar al
menú inicial:
Figura 3.16
Lea detenidamente los comentarios de cada línea del programa. Observe que en esta
oportunidad hemos utilizado un alias para cada una de las entradas utilizadas en el puerto D
(RD0 se llamará Pulsador_1, y RD1 se llamará Pulsador_2).
Symbol Pulsador_1 = PortD.0 ' Alias para RD0
Symbol Pulsador_2 = PortD.1 ' Alias para RD1
Dim texto1 As string[16] ' Variable tipo String "texto1"

_______________________________________________________________________________________
101
TRISD = $FF ' Configuración del puerto D como entrada.
main:
menu:
texto1 = "P1: Ver Mensaje1" ' cargamos el texto en la variable
texto2 = "P2: Ver Mensaje2" ' cargamos el texto en la variable
If Pulsador_1 = 1 Then ' Pregunta si RD0 fue presionado.
GoSub menu1 ' Si fué presionado, salta a la subrutina "menu1"
End If
If Pulsador_2 = 1 Then ' Pregunta si RD1 fue presionado.
GoSub menu2 ' Si fué presionado, salta a la subrutina "menu2"
End If
GoTo menu ' Repite el proceso a partir de la etiqueta "menu"
menu1:
texto1 = " Menu #1 " ' cargamos el texto en la variable
texto2 = "Mensaje #1 aqui!" ' cargamos el texto en la variable
delay_ms(5000) ' Retardo o pausa de 5 segundos
Return ' retorna a la siguiente linea despues del último llamado
' a la etiqueta "menu1"
menu2:
texto1 = " Menu #2 " ' cargamos el texto en la variable
texto2 = "Mensaje #2 aqui!" ' cargamos el texto en la variable
delay_ms(5000) ' Retardo o pausa de 5 segundos
Return ' retorna a la siguiente linea despues del último llamado
' a la etiqueta "menu2"
End.

_______________________________________________________________________________________
102
Analizando el programa tenemos que:
El primer paso ha sido crear un Alias a los pines de entrada RD0 y RD1. En este
caso, como el pulsador P1 lo hemos conectado en el pin RD0, entonces le hemos
dado el nombre o alias de “pulsador_1”. Para el pulsador P2, el cual está conectado
en el pin RD1 hemos designado el alias de “pulsador_2”. Los alias son muy útiles a la
hora de realizar programas relativamente extensos, ya que de esta forma no es
necesario tener que estar recordando en cual pin hemos conectado un pulsador, Led,
relé o cualquier otro dispositivo de entrada o salida. Bastará entonces con recordar el
nombre del mismo previamente asignado a través de un alias.
Declaración de las variables en las cuales deseamos almacenar el texto a ser
mostrado en la pantalla LCD.
Configuración de pines de la pantalla LCD con respecto al puerto elegido en el
microcontrolador.
Inicializamos y limpiamos la pantalla, apagamos el cursor y realizamos una pausa de
1 segundo.
Cargamos el mensaje del menú principal en las variables designadas para cada línea
de la pantalla LCD.
Imprimimos el contenido de las variables en la pantalla LCD, en las posiciones
especificadas en la rutina Lcd_Out.
Preguntamos si algunos de los pulsadores ha accionado. Si uno de ellos fue
accionado, se realiza un salto con retorno a la rutina correspondiente. Si ninguno ha
sido accionado, se repite todo el proceso a partir de la etiqueta “menu”.

_______________________________________________________________________________________
103
3.4.- Pantalla Gráfica o GLCD (Graphic Liquid Crystal Display).
MikroBasic cuenta con librerías para el control de pantallas GLCD, facilitando la tarea y
haciendo que nuestros proyectos se vean mejor, ofreciendo además funciones que no
podríamos tener con una pantalla alfanumérica convencional.
Por su puesto, el uso de una pantalla gráfica se justifica cuando es necesario incluir en
nuestros proyectos mas espacio para la visualización de datos, sin dejar atrás el hecho de
que podremos realizar gráficos o dibujos que complementen dicha información, y los cuales
nunca podremos realizar en una pantalla alfanumérica convencional.
Para realizar el estudio de estas librerías, hemos realizado el siguiente diagrama de
conexión entre un módulo GLCD y un microcontrolador PIC16F877.
La pantalla GLCD utilizada para estos ejemplos es la LGM12864B-NSW-BBS, la cual se
puede adquirir al igual que muchos otros componentes en http://www.mikroe.com
Figura 3.17

_______________________________________________________________________________________
104
3.5.- Configuración de pines de control y datos en mikroBasic.
Al igual que para una pantalla LCD, el primer paso siempre será establecer la configuración
de pines entre el módulo GLCD y el microcontrolador. Sin este paso el módulo nunca
arrancará, evitando que podamos avanzar en la programación de nuestros proyectos.
Para inicializar la pantalla GLCD según la configuración de pines del diagrama de la figura
3.17, usaremos el siguiente arreglo:
' Configuración de conección del módulo Glcd
Dim GLCD_DataPort As Byte At PORTD
Dim GLCD_CS1 As sbit At RB0_bit
GLCD_CS2 As sbit At RB1_bit
GLCD_RS As sbit At RB2_bit
GLCD_RW As sbit At RB3_bit
GLCD_EN As sbit At RB4_bit
GLCD_RST As sbit At RB5_bit
Dim GLCD_CS1_Direction As sbit At TRISB0_bit
GLCD_CS2_Direction As sbit At TRISB1_bit
GLCD_RS_Direction As sbit At TRISB2_bit
GLCD_RW_Direction As sbit At TRISB3_bit
GLCD_EN_Direction As sbit At TRISB4_bit
GLCD_RST_Direction As sbit At TRISB5_bit
' Fin de la configuración del módulo Glcd
Puerto de Control PortD
CS1 0 (RB0)
CS2 1 (RB1)
RS 2 (RB2)
RW 3 (RB3)
EN 4 (RB4)
RST 5 (RB5)
Puerto de datos PortD
Los pines CS1 y CS2 son importantes, debido a que la pantalla Glcd está dividida en dos
partes iguales, similar a un libro abierto con dos páginas en blanco en las cuales podremos
escribir. Llamemos a estas dos páginas CS1 (primera página) y CS2 (segunda página).

_______________________________________________________________________________________
105
Figura 3.18
Si deseamos escribir una palabra o el contenido de una variable en la pantalla, incluso si
deseamos graficar algo, se tomará como pagina de inicio la primera. Por ejemplo, si
deseamos escribir la palabra “mikroBasic” en la línea 4, columna 0 de la pantalla Glcd
(usando la rutina Glcd_Write_Text("mikroBasic", 0, 4, 1) la cual estudiaremos mas
adelante), y declaramos los pines CS1 y CS2 como se sugiere a continuación, con respecto
al diagrama esquemático de la figura 3.17:
Entonces, la palabra “mikroBasic” aparecerá en la página de la izquierda, es decir, en la
página 1.
Figura 3.19
Pero si llegáramos a invertir esta configuración, ya sea por software:

_______________________________________________________________________________________
106
También por hardware, invirtiendo el conexionado de pines entre el microcontrolador y la
pantalla, y manteniendo la ubicación de la palabra “mikroBasic” en la pantalla, es decir, línea
4 y columna 0, el resultado sería que la palabra “mikroBasic” sigue estando en la primera
página, solo que esta vez se encontrará a la derecha de la pantalla, tal y como se muestra a
continuación:
Figura 3.20
3.5.- Librería GLCD.
La librería GLCD nos ofrece un repertorio de rutinas muy útiles que nos permiten hacer de la
programación para el control de estos dispositivos una tarea sencilla y de fácil comprensión.
Realizaremos un estudio detenido de cada rutina aplicando su función específica en
ejemplos cortos y sencillos para tener una base clara y práctica sobre el tema y la cual será
empleada en varios nuevos proyectos en los capítulos posteriores a éste.
3.5.1.- Rutina Glcd_Init().
Para inicializar la pantalla Glcd se debe usar la rutina Glcd_Init(), como lo demostraremos
mas adelante con un programa de ejemplo. Una vez inicializada la pantalla, podremos
escribir o a dibujar en ella, utilizando algunas rutinas disponibles en la librería Glcd de
mikroBasic.
El tamaño de la fuente por defecto, cuando utilizamos la rutina para escribir texto es de 5 x 7
pixeles. Esto significa que podremos escribir texto en la pantalla en una ubicación
específica, sin necesidad de llamar a un archivo de fuentes en el programa.
Un ejemplo de esto se puede ver a continuación en el siguiente ejemplo. La rutina que
utilizaremos para escribir en la pantalla en este ejemplo está explicada detalladamente mas
adelante.

_______________________________________________________________________________________
107
program pantalla_glcd_01
main:
Glcd_Init() ' Inicializamos la pantalla
Glcd_Fill(0) ' Limpiamos la pantalla
Glcd_Write_Text("Lenguaje Basic", 22, 1, 1)
Glcd_Write_Text("para", 54, 2, 1)
Glcd_Write_Text("Microcontroladores", 8, 3, 1)
Glcd_Write_Text("PIC", 55, 4, 1)
Glcd_Write_Text("''Pantalla GLCD''", 16, 6, 1)
End.
El resultado de este ejemplo se verá de la siguiente manera en la pantalla Glcd:
Figura 3.21

_______________________________________________________________________________________
108
Sin embargo, es importante saber que los caracteres que vamos a escribir también pueden
estar asociados a un módulo de fuentes adicional, el cual define la forma o estilo de cada
carácter de una manera personalizada.
3.5.3.- Módulo de Fuentes en mikroBasic.
Este módulo de fuentes es un archivo de extensión .mbas el cual podemos crear para definir
el estilo de caracteres que deseamos mostrar en la pantalla LCD.
Por ejemplo, podríamos crear un archivo de fuentes de nombre “mis_fuentes.mbas”, y en él
definir el estilo de cada caracter que deseamos mostrar en la pantalla Glcd.
Para crear este archivo de fuentes, es importante saber como crear la fuente para cada
caracter.
Al igual que en la primera edición del libro “Basic para microcontroladores PIC”, vamos a
apoyarnos en una pequeña tabla cuadriculada para generar un caracter de estilo
personalizado. Los caracteres que a continuación vamos a definir serán de 5 columnas por 8
filas. Empecemos creando un “font” para la letra A:
Figura 3.22
En la figura anterior, cada cuadro estará asociado a un píxel en la pantalla. Cada caracter
estará asociado a su vez a un valor que representaremos en hexadecimal, para cada una de
las columnas de la figura anterior. Es decir, si observamos la siguiente figura, podremos ver
que hemos identificado cada fila y cada columna. La primera columna “c1”, tendrá un valor
asociado que dependerá directamente de los píxeles que deseamos activar para formar una
figura. Entonces, basados en la columna 1 de la figura 3.22, podríamos decir que solo
activaremos los píxeles correspondientes a las filas 2, 3, 4, 5, 6 y 7 (marcados por una “x”).

_______________________________________________________________________________________
109
c1 c2 c3 c4 c5
f1
f2 x
f3 x
f4 x
f5 x
f6 x
f7 x
f8
Figura 3.23
Esta columna deberá generar un byte el cual representaremos en el archivo
“mis_fuentes.mbas”, en su forma hexadecimal, donde el bit menos significativo será la fila 1
y el bit mas significativo será la fila 8, siendo la “x” un píxel activo y recordando del sistema
numérico binario lo siguiente:
c1 c2 c3 c4 c5
f1 1
f2 2
f3 4
f4 8
f5 16
f6 32
f7 64
f8 128
Figura 3.24
Sumando los píxeles activos o marcados por la “x” tenemos que:
2 + 4 + 8 + 16 + 32 + 64 = 126, en hexadecimal: $7E
Para recordar un poco esta conversión, acostemos la columna 1 en sentido horario y
veamos lo siguiente:
128
27
64
26
32
25
16
24
8
23
4
22
2
21
1
20
F8
F7
F6
F5
F4
F3
F2
F1
Figura 3.25

_______________________________________________________________________________________
110
Byte = 01111110
7 E
x x x x x x
F8
F7
F6
F5
F4
F3
F2
F1
Figura 3.26
Valor Hexadecimal: 0111 = 7 07h
1110 = 14 0Eh
Entonces, el valor del byte en Hexadecimal es 7Eh, ó en formato hexadecimal para
mikroBasic, $7E.
Calculando los valores para el resto de las columnas, tenemos que:
c1 c2 c3 c4 c5
f1 x x x
f2 x x
f3 x x
f4 x x
f5 x x x x x
f6 x x
f7 x x
f8
Figura 3.27
C1 = 2 + 4 + 8 + 16 + 32 + 64 = 126 (dec) = $7E (hex)
C2 = 1 + 16 = 17 (dec) = $11 (hex)
C3 = 1 + 16 = 17 (dec) = $11 (hex)
C4 = 1 + 16 = 17 (dec) = $11 (hex)
C5 = 2 + 4 + 8 + 16 + 32 + 64 = 126 (dec) = $7E (hex)

_______________________________________________________________________________________
111
Veamos a continuación un módulo de “fonts” ya creado, y ubiquemos el caracter “A” en el
código:
module mis_fuentes
const Fuentes5x8 As Byte[490] = (
$00,$00,$00,$00,$00, '* Espace $20 */
$00,$00,$4f,$00,$00, '* ! */
$00,$07,$00,$07,$00, '* " */
$14,$7f,$14,$7f,$14, '* # */
$24,$2a,$7f,$2a,$12, '* $ */
$23,$13,$08,$64,$62, '* % */
$36,$49,$55,$22,$20, '* & */
$00,$05,$03,$00,$00, '* ' */
$00,$1c,$22,$41,$00, '* ( */
$00,$41,$22,$1c,$00, '* ) */
$14,$08,$3e,$08,$14, '* ' */
$08,$08,$3e,$08,$08, '* + */
$50,$30,$00,$00,$00, '* , */
$08,$08,$08,$08,$08, '* - */
$00,$60,$60,$00,$00, '* . */
$20,$10,$08,$04,$02, '* / */
$3e,$51,$49,$45,$3e, '* 0 $30 */
$00,$42,$7f,$40,$00, '* 1 */
$42,$61,$51,$49,$46, '* 2 */
$21,$41,$45,$4b,$31, '* 3 */
$18,$14,$12,$7f,$10, '* 4 */
$27,$45,$45,$45,$39, '* 5 */
$3c,$4a,$49,$49,$30, '* 6 */
$01,$71,$09,$05,$03, '* 7 */
$36,$49,$49,$49,$36, '* 8 */
$06,$49,$49,$29,$1e, '* 9 */
$00,$36,$36,$00,$00, '* as */
$00,$56,$36,$00,$00, '* */
$08,$14,$22,$41,$00, '* < */
$14,$14,$14,$14,$14, '* = */
$00,$41,$22,$14,$08, '* > */
$02,$01,$51,$09,$06, '* ? */
$3e,$41,$5d,$55,$1e, '* @ $40 */
$7e,$11,$11,$11,$7e, '* A */
$7f,$49,$49,$49,$36, '* B */
$3e,$41,$41,$41,$22, '* C */
$7f,$41,$41,$22,$1c, '* D */
$7f,$49,$49,$49,$41, '* E */
$7f,$09,$09,$09,$01, '* F */
$3e,$41,$49,$49,$7a, '* G */
$7f,$08,$08,$08,$7f, '* H */
$00,$41,$7f,$41,$00, '* I */
$20,$40,$41,$3f,$01, '* J */
$7f,$08,$14,$22,$41, '* K */
$7f,$40,$40,$40,$40, '* L */
$7f,$02,$0c,$02,$7f, '* M */
$7f,$04,$08,$10,$7f, '* N */
$3e,$41,$41,$41,$3e, '* O */
$7f,$09,$09,$09,$06, '* P $50 */
$3e,$41,$51,$21,$5e, '* Q */
$7f,$09,$19,$29,$46, '* R */
$26,$49,$49,$49,$32, '* S */
$01,$01,$7f,$01,$01, '* T */
$3f,$40,$40,$40,$3f, '* U */
$1f,$20,$40,$20,$1f, '* V */
$3f,$40,$38,$40,$3f, '* W */
$63,$14,$08,$14,$63, '* X */
$07,$08,$70,$08,$07, '* Y */
$61,$51,$49,$45,$43, '* Z */
$00,$7f,$41,$41,$00, '* [ */
$02,$04,$08,$10,$20, '* */
$00,$41,$41,$7f,$00, '* ] */
$04,$02,$01,$02,$04, '* ^ */
$40,$40,$40,$40,$40, '* _ */
$00,$00,$03,$05,$00, '* ` $60 */

_______________________________________________________________________________________
112
$20,$54,$54,$54,$78, '* a */
$7F,$44,$44,$44,$38, '* b */
$38,$44,$44,$44,$44, '* c */
$38,$44,$44,$44,$7f, '* d */
$38,$54,$54,$54,$18, '* e */
$04,$04,$7e,$05,$05, '* f */
$08,$54,$54,$54,$3c, '* g */
$7f,$08,$04,$04,$78, '* h */
$00,$44,$7d,$40,$00, '* i */
$20,$40,$44,$3d,$00, '* j */
$7f,$10,$28,$44,$00, '* k */
$00,$41,$7f,$40,$00, '* l */
$7c,$04,$7c,$04,$78, '* m */
$7c,$08,$04,$04,$78, '* n */
$38,$44,$44,$44,$38, '* o */
$7c,$14,$14,$14,$08, '* p $70 */
$08,$14,$14,$14,$7c, '* q */
$7c,$08,$04,$04,$00, '* r */
$48,$54,$54,$54,$24, '* s */
$04,$04,$3f,$44,$44, '* t */
$3c,$40,$40,$20,$7c, '* u */
$1c,$20,$40,$20,$1c, '* v */
$3c,$40,$30,$40,$3c, '* w */
$44,$28,$10,$28,$44, '* x */
$0c,$50,$50,$50,$3c, '* y */
$44,$64,$54,$4c,$44, '* z */
$08,$36,$41,$41,$00, '* { */
$00,$00,$77,$00,$00, '* | */
$00,$41,$41,$36,$08, '* } */
$08,$08,$2a,$1c,$08, '* <- */
$08,$1c,$2a,$08,$08, '* -> */
$ff,$ff,$ff,$ff,$ff,
$06,$09,$09,$06,$00 ' oC $81
)
implements
End.
Esta tabla posee el código para crear 98 caracteres personalizados, donde cada caracter
tiene asignado 5 bytes, dando como resultado la declaración de 490 variables tipo byte,
como se observa en la cabecera de la tabla:
Se puede observar claramente que el caracter “A” tiene asignado los 5 bytes,
correspondientes a los cálculos que hemos efectuado anteriormente. De igual forma
deberán existir los bytes calculados para cada uno de los caracteres que deseamos mostrar
en la pantalla Glcd.
Una vez que hemos realizado todos los cálculos para cada uno de los caracteres,
procedemos a dar el formato adecuado al archivo de “fonts” que hemos creado. Este
archivo, el cual llevará el nombre de “mis_fuentes.mbas” (este nombre puede ser también
personalizado), deberá ser grabado en una ruta conocida, por ejemplo, en la misma carpeta
en la cual crearemos el proyecto para visualizar caracteres en la pantalla.
Hagamos el ejercicio tomando como punto de partida la creación del archivo de fuentes
personalizadas mostrado anteriormente:

_______________________________________________________________________________________
113
1.- Abrimos mikroBasic:
Figura 3.28
Hacemos clic en el menú “File” y seleccionamos la opción “New Unit”, o simplemente
accedemos a esta opción a través del atajo “Ctrl+N”.
Figura 3.29

_______________________________________________________________________________________
114
2.- Copiamos el código del archivo de fuentes personalizadas que hemos creado con
anterioridad, y lo guardamos en una ruta conocida con el nombre de mis_fuentes.mbas
como se muestra a continuación:
Figura 3.30

_______________________________________________________________________________________
115
Este archivo es importante porque contiene el código responsable de dar forma a cada
número, letra, o caracter especial que deseamos mostrar en la pantalla Glcd. Además, este
archivo deberá estar en la misma ruta o carpeta en la cual está el proyecto en el cual
realizaremos el código correspondiente para escribir en la pantalla.
3.- Creamos un nuevo proyecto en mikroBasic, el cual estará basado en el diagrama
esquemático de la figura 3.17. Haciendo clic en el menú “Project” y seguidamente en “New
Project”. En este punto, tendremos la asistencia de mikroBasic a través de “New Project
Wisard” para configurar convenientemente nuestro proyecto.
Figura 3.31

_______________________________________________________________________________________
116
Veamos ahora el programa de ejemplo que nos permitirá finalmente escribir en la pantalla
Glcd en base al módulo de fuentes descrito anteriormente.
program Proyecto_Glcd_02
Include mis_fuentes ' Incluimos el archivo de fuentes
Dim texto As String[20] ' Declaramos una variable tipo String en la cual
' cargaremos un mensaje de un máximo de 20 caracteres.
main:
Glcd_Init()
Glcd_Fill(0x00) ' Limpiamos la pantalla
Glcd_Set_Font(@fuentes5x8, 5, 8, 32) ' Elegimos el módulo de fuentes
texto = "mikroBasic" ' cargamos la variable con un mensaje
Glcd_Write_Text(texto, 35, 3, 1) ' Escribimos el contenido de la
' variable "texto"
End.
Figura 3.32

_______________________________________________________________________________________
117
Analicemos el programa:
Incluimos el módulo de fuentes “mis_fuentes.mbas” en el programa a través de la
instrucción “include”. No es necesario escribir la extensión del archivo.
Declaramos una variable tipo string, en cual almacenaremos el contenido del mensaje
que deseamos mostrar en la pantalla.
Configuramos e inicializamos la pantalla Glcd, basados en el diagrama de conexión
de la figura 3.17.
Limpiamos la pantalla Glcd, llenando cada píxel con un cero lógico a través de la
rutina Glcd_Fill(), la cual detallaremos a continuación.
Cargamos el módulo de fuentes de 5x8 a través de la rutina Glcd_Set_Font(), la cual
detallaremos a continuación.
Cargamos el mensaje en la variable “texto”.
Enviamos el mensaje cargado en la variable “texto” a la pantalla Glcd a través de la
rutina Glcd_Write_Text() la cual detallaremos a continuación.
3.5.4.- Glcd_Fill().
La rutina Glcd_Fill(), es utilizado para llenar el contenido de la memoria de la pantalla con el
dato especificado. Normalmente, esta rutina es utilizada para limpiar la pantalla llenando la
misma con un cero lógico (0) en cada píxel, o para verificar la pantalla observando cada
píxel encendido al aplicar un uno lógico (1) en cada uno de ellos. Entonces, si escribimos
Glcd_Fill(0), tendremos todos los píxeles apagados, y si escribimos Glcd_Fill($FF)
tendremos todos los píxeles encendidos.
En nuestro programa, hemos escrito Glcd_Fill(0x00), la cual es una forma de un número en
hexadecimal.
3.5.5.- Glcd_Set_Font().
La rutina Glcd_Set_Font(), es utilizada para seleccionar el tipo de fuente que deseamos
mostrar dentro de nuestro archivo de fuentes creado. Esto infiere que podemos tener en el
mismo archivo de fuentes distintos modelos de fuentes definidos por un nombre declarado
como variable al inicio de cada tabla de datos.
Por ejemplo:
module mis_fuentes

_______________________________________________________________________________________
118
$00,$00,$00,$00,$00, '* Espace $20 */
.
.
.
.
$06,$09,$09,$06,$00 ' oC $81
)
const Fuentes3x6 as byte[195] = (
$00,$00,$00, '* Espace $20 */
.
.
.
.
$04,$08,$00 '* ` $60 */
)
implements
End.
Observe que en el módulo “mis_fuentes”, ahora tenemos fuentes para caracteres de 5x8
pixeles llamado “Fuentes5x8”, y fuentes para caracteres de 3x6 pixeles llamado
“Fuentes3x6”.
En nuestro programa hemos elegido las fuentes de 5x8 de la siguiente forma:
Glcd_Set_Font(dirección de la fuente, ancho, alto, posición inicial en la tabla ASCII)
Glcd_Set_Font(@fuentes5x8, 5, 8, 32)
El primer campo de la rutina define que fuentes debe tomar el modulo Glcd. Se accede al
nombre de la fuente “fuentes5x8” a través de operador “@”.
El segundo campo (ancho ó font_width) define la cantidad de columnas que tiene la fuente
especificada.
El tercer campo (alto ó font_height) define la cantidad de filas que tiene la fuente
especificada.
El cuarto campo (font_offset) define el carácter inicial en la tabla ASCII a partir del cual la
pantalla Glcd asociará los caracteres cargados en la variable “texto” con la tabla de fuentes
que hemos creado en nuestro archivo “mis_fuentes.mbas”.

_______________________________________________________________________________________
119
3.5.6.- Glcd_Write_Text().
La rutina Glcd_Write_Text() escribe un texto previamente cargado en el campo
correspondiente de la rutina, en la pantalla Glcd. La rutina cuenta con cuatro campos los
cuales describiremos a continuación:
Glcd_Write_Text(texto, posición en x, línea, color)
En el campo “texto” podemos escribir directamente un mensaje entre comillas, o podemos
escribir la variable tipo string en la cual hemos cargado el mensaje.
El campo “Posición en x”, indica a partir de que píxel en el eje X de la pantalla empezaremos
a escribir nuestro mensaje. En nuestro ejemplo hemos utilizado una pantalla de 128 x 64
pixeles, siendo 128 la cantidad de pixeles del eje X. Entonces, si observamos el programa,
podremos observar que el punto de partida de nuestro mensaje con respecto al eje X de la
pantalla será el píxel número 35.
El campo “línea”, indica el número de línea en la cual vamos a escribir, a partir de la línea 0
hasta la línea 7. La cantidad de líneas en este tipo de pantallas al escribir texto, depende
sólo del tamaño de la fuente que hemos creado. En nuestro caso, tendremos un total de 8
líneas para una fuente de 5x8 pixeles.
En el campo color, escribimos “1” cuando deseamos que los caracteres tengan sus pixeles
encendidos y el fondo apagado, y escribimos “0” cuando deseamos que el fondo de los
caracteres tengan sus pixeles encendidos y los pixeles del los caracteres apagados.
Es decir, si el campo “color” es igual a 1, el resultado será el siguiente:
Figura 3.33

_______________________________________________________________________________________
120
Es decir, si el campo “color” es igual a 0, el resultado será el siguiente:
Figura 3.34
Realice los cambios necesarios en la rutina Glcd_Write_Text() en el programa anteriormente
expuesto de tal manera que pueda mostrar un mensaje personalizado no mayor a 20
caracteres, en diferentes posiciones variando los campos de ésta.
Veamos ahora la forma de presentar el contenido almacenado en una variable en la pantalla
Glcd. En este caso es importante mencionar nuevamente que esto será posible si utilizamos
la librería “Conversions”, la cual nos permite convertir el contenido de una variable tipo
byte, Word, LongWord, LongInt, Float, Int, todas en un string de datos listos para ser
visualizados.
Veamos algunos ejemplos prácticos de conversión.
Para una variable tipo byte:
Dim dato As Byte
datoStr As String[3]
dato = 20 Conversión: byteToStr(dato, datoStr)
Para una variable tipo word:
Dim dato As Word
dato = 1023 Conversión: wordToStr(dato, datoStr)

_______________________________________________________________________________________
121
Para una variable tipo float:
Dim dato As Float
dato = 3.1415161718 Conversión: floatToStr(dato, datoStr)
Veamos a continuación un ejemplo en el cual se imprime el valor de una variable tipo Word
en una posición predeterminada de la pantalla Glcd.
Dim dato As Word ' Declaramos una variable tipo Word.
datoStr As String[5] ' Declaramos una variable tipo String.
main:
dato = 32768 ' Cargamos un valor en la variable “dato”
wordToStr(dato, datoStr) ' Convertimos la variable de word a string.
Glcd_Fill(0x00) ' Limpiamos la pantalla
texto = "Variable Dato: " ' cargamos la variable con un mensaje
Glcd_Write_Text(texto, 5, 1, 1) ' Escribimos el contenido de la
' variable "texto"
Glcd_Write_Text(datoStr, 94, 1, 1) ' Escribimos el contenido de la
' variable "datoStr"
End.

_______________________________________________________________________________________
122
Figura 3.35
MikroBasic cuenta con algunas otras rutinas para graficar en una pantalla Glcd que
seguramente nos ayudaran a desarrollar nuevas ideas para nuestros proyectos.
Veamos a continuación cuales son las rutinas para crear gráficos de una forma simple y
rápida.
3.5.7.- Glcd_Dot(x, y, color).
Esta rutina nos permite encender o apagar un píxel específico en la pantalla, a través de sus
coordenadas (x, y).
El campo color tiene tres posibles estados:
0, apaga el píxel especificado.
1, enciende el píxel especificado.
2, invierte el estado del píxel especificado.
Veamos el siguiente ejemplo, basado en el diagrama esquemático de la figura 3.17.

_______________________________________________________________________________________
123
main:
Glcd_Dot(64, 32, 1) ' activamos el píxel en X = 0 , Y = 0
End.
El resultado es el siguiente:
Figura 3.36
El programa enciende el píxel de coordenadas X = 64, Y = 32, es decir, en el centro de la
pantalla GLCD la cual es de 128 x 64 pixeles.
Para poder observar el efecto opuesto, en vez de limpiar la pantalla a través de la rutina
Glcd_Fill(0), llenaremos con un 1 lógico en cada píxel, utilizando la rutina Glcd_Fill($FF), y
seguidamente apagaremos un píxel específico de coordenada (64, 32).

_______________________________________________________________________________________
124
main:
Glcd_Fill($FF) ' Llenamos la pantalla
Glcd_Dot(64, 32, 0) ' activamos el píxel en X = 0 , Y = 0
End.
Para ver el efecto de cambio de estado de un Píxel cuando el campo “color” es igual a 2,
hacemos una pequeña modificación al programa anterior, de tal manera que el píxel
especificado cambie de estado cada 1 segundo.
main:
Glcd_Fill($FF) ' Llenamos la pantalla con un 1 lógico en cada pixel
intermitencia:
Glcd_Dot(64, 32, 2) ' cambiamos el estado del píxel en X = 64 , Y = 32
Delay_ms(1000) ' retardo de 1 segundo
GoTo intermitencia ' salto a la etiqueta "intermitencia"
End.

_______________________________________________________________________________________
125
3.5.8.- Glcd_Line(x1, y1, x2, y2, color).
Esta rutina dibuja una línea entre dos coordenadas específicas, (x1, y1) y (x2, y2). El estado
de los píxeles de la línea, al igual que en la rutina anterior está definido por el campo “color”.
Es decir, cuando el campo “color” es igual a:
0, apaga los píxeles de la línea.
1, enciende los píxeles de la línea.
2, invierte el estado de los píxeles en la línea.
Veamos un ejemplo práctico.
main:
Glcd_Line(30, 15, 100, 15, 1) ' Linea Horzontal:
' (x1=30, y1=15)(x2=100, y2=15)
Glcd_Line(20, 20, 20, 50, 1) ' Linea Vertical:
' (x1=20, y1=20)(x2=20, y2=50)
Glcd_Line(25, 58, 100, 20, 1) ' Linea Diagonal:
' (x1=25, y1=58)(x2=100, y2=20)
End.

_______________________________________________________________________________________
126
Figura 3.37
Veamos como sería el efecto inverso.
main:
Glcd_Fill($FF) ' Llenamos la pantalla
Glcd_Line(30, 15, 100, 15, 0) ' Linea Horzontal:
' (x1=30, y1=15)(x2=100, y2=15)
Glcd_Line(20, 20, 20, 50, 0) ' Linea Vertical:
' (x1=20, y1=20)(x2=20, y2=50)
Glcd_Line(25, 58, 100, 20, 0) ' Linea Diagonal:
' (x1=25, y1=58)(x2=100, y2=20)
End.

_______________________________________________________________________________________
127
Figura 3.38
3.5.9.- Glcd_V_Line(y1, y2, x, color).
Esta rutina nos permite dibujar una línea vertical en la pantalla Glcd. Para esto, solo será
necesario indicar los dos valores entre los cuales se dibujará la línea, y el valor
correspondiente al eje x, en el cual estará ubicada dicha línea.
Al igual que en la rutina anterior, cuando el campo “color” es igual a:

_______________________________________________________________________________________
128
main:
Glcd_V_Line(1, 62, 63, 1) ' Linea Vertical:
' (y1=1)(Y2=62)(x=63)
End.
Figura 3.39
3.5.10.- Glcd_H_Line(x1, x2, y, color).
Esta rutina nos permite dibujar una línea horizontal en la pantalla Glcd. Para esto, solo será
necesario indicar los dos valores entre los cuales se dibujará la línea, y el valor
correspondiente al eje y, en el cual estará ubicada dicha línea.
Al igual que en la rutina anterior, cuando el campo “color” es igual a:

_______________________________________________________________________________________
129
main:
Glcd_H_Line(1, 127, 32, 1) ' Linea Horizontal:
' (y1=1)(Y2=62)(x=63)
End.
Figura 3.40

_______________________________________________________________________________________
130
3.5.11.- Glcd_Rectangle(x1, y1, x2, y2, color).
Esta rutina nos permite dibujar un cuadrado o rectángulo especificando tan solo dos
esquinas opuestas diagonales, Las coordenadas de estas dos esquinas determinarán el
tamaño en píxeles, y el campo “color” aplica las mismas reglas de las rutinas anteriores:
Veamos a continuación dos ejemplos prácticos.
main:
Glcd_Rectangle(26, 26, 102, 38, 1) ' Rectángulo:
' (x1=26)(Y1=26)(x2=102)(y2=38)
End.
Figura 3.41

_______________________________________________________________________________________
131
Analice cuidadosamente el siguiente ejemplo.
Dim x1 As Byte ' Declaración de variables para coordenadas de puntos.
x2 As Byte '
y1 As Byte '
y2 As Byte '
main:
x1 = 0 ' Inicializamos las variables con los datos necesarios
y1 = 0 ' para generar un rectangulo de coordenadas máximas en una
x2 = 127 ' pantalla de 128 x 64 píxeles.
y2 = 63
rectangulo:
Glcd_Rectangle(x1, y1, x2, y2, 1) ' Rectángulo:
' (x1=26)(Y1=26)(x2=102)(y2=38)
delay_ms(500) ' retardo de 500 milisegundos
x1 = x1 + 2 ' Incrementamos en dos unidades el valor de x1
y1 = y1 + 2 ' Incrementamos en dos unidades el valor de y1
x2 = x2 - 2 ' Decrementamos en dos unidades el valor de x2
y2 = y2 - 2 ' Decrementamos en dos unidades el valor de x2
If x1 > 30 Then ' Imponemos un límite en el tamaño del cuadro.
GoSub inicializa ' Si el límite se cumple, inicializamos las
End If ' coordenadas y limpiamos la pantalla para
' repetir todo el proceso.
GoTo rectangulo ' Salta a la etiqueta "rectangulo"
inicializa:
delay_ms(500) ' Retardo de 500 milisegundos
x1 = 0 ' Inicializamos las variables:
y1 = 0 '
x2 = 127 '
y2 = 63 '
Glcd_Fill(0) ' Limpia la pantalla
Return ' Retorno
End.

_______________________________________________________________________________________
132
Cada 500 milisegundos se formará un rectángulo de menor tamaño que el anterior hasta
llegar al límite especificado en el programa para luego limpiar la pantalla y repetir el proceso
ilimitadamente.
Figura 3.42
3.5.12.- Glcd_Box(x1, y1, x2, y2, color).
Al igual que en la rutina anterior, con esta rutina podemos dibujar un cuadrado o rectángulo.
La diferencia radica en que esta vez se activaran todos los píxeles internos.
Veamos un ejemplo.

_______________________________________________________________________________________
133
main:
Glcd_Box(26, 26, 102, 38, 1) ' Rectángulo:
' (x1=26)(Y1=26)(x2=102)(y2=38)
End.
Figura 3.43
Si invertimos el fondo de la pantalla y cambiamos el campo “color” en la rutina a “0” tenemos
que:
main:
Glcd_Fill($FF) ' Limpiamos la pantalla
Glcd_Box(26, 26, 102, 38, 0) ' Rectángulo:
' (x1=26)(Y1=26)(x2=102)(y2=38)
End.

_______________________________________________________________________________________
134
Figura 3.44
3.5.13.- Glcd_Circle(x, y, radio, color).
Esta rutina genera un circulo en la pantalla Glcd, siendo (x, y) la coordenada del centro del
circulo, de radio definido en píxeles en el campo del mismo nombre, y al igual que en las
rutinas anteriores, de color activo específico.
Veamos un ejemplo.
main:
Glcd_Circle(63, 31, 25, 1) ' Círculo.
End.

_______________________________________________________________________________________
135
Figura 3.45
(Como ejercicio adicional a este ejemplo, se podría aumentar el tamaño del radio, sobrepasando el límite
permitido por el número de píxeles de la pantalla. El resultado es muy interesante).
La solución respectiva para su forma inversa sería la siguiente:
main:
Glcd_Fill($FF) ' Limpiamos la pantalla
Glcd_Circle(63, 31, 25, 0) ' Círculo.
End.

_______________________________________________________________________________________
136
Figura 3.46
Otro ejemplo interesante podría ser dibujar una secuencia de círculos utilizando la
instrucción For – Next:
Dim Radio As Byte ' Declaramos la variable "Radio" para poder modificar
' el tamaño de los circulos consecutivos.
I As Byte ' Variable para generar repeticiones a través de la
' instrucción For-Next.
main:
Radio = 26 ' Establecemos el radio del primer circulo.
For I = 0 To 10 ' Díez repeticiones de la siguiente rutina:
Glcd_Circle(63, 31, Radio, 1) ' Círculo
Radio = Radio - 2 ' Decrementamos el radio en 2 unidades.

_______________________________________________________________________________________
137
delay_ms(500) ' Retardo de 500 milisegundos.
Next I
End.
El resultado es el siguiente:
Figura 3.47

_______________________________________________________________________________________
138
Capítulo IV. Librería Trigon – Funciones Trigonométricas
4.1.- Funciones Trigonométricas.
Veamos a continuación algunas funciones trigonométricas disponibles en mikroBasic que
nos permitirán realizar algunos cálculos complejos de una forma sencilla y práctica:
sin(x): calcula el seno del valor de “x”. Retorna un valor en radianes entre -1 y 1.
sinh(x): calcula el seno hiperbólico de “x”, definido matemáticamente como
2
x
x
e
e
.
cos(x): calcula el coseno del valor de “x”. Retorna un valor en radianes entre -1 y 1.
cosh(x): calcula el coseno hiperbólico de “x”, definido matemáticamente como
2
x
x
e
e
.
tan(x): calcula el valor de la tangente de “x” en radianes.
tanh(x): calcula la tangente hiperbólica de “x”, definida matemáticamente como
sinh(x)/cosh(x).
Asin(x): calcula el arco seno del valor de “x” en el intervalo de -1 a 1. Retorna un valor
en radianes entre –
Acos(x): calcula el arco coseno del valor de “x” en el intervalo de -1 a 1. Retorna un
valor en radianes entre
Atan(x): Calcula el arco tangente del valor de “x”, es decir, el valor cuya tangente es
“x”. Retorna un valor en radianes entre –
Atan2(x, y): Es similar a calcular la arcotangente de Y / X, excepto que los signos de
ambos argumentos se utilizan para determinar el cuadrante del resultado y X se le
permite ser cero.
Log(x): calcula el logaritmo natural o neperiano (ln) de “x”.
Log10(x): calcula el logaritmo base 10 de “x”.
sqrt(x): calcula la raíz cuadrada de “x”.
exp(x): La función devuelve el valor de e, la base de los logaritmos naturales, elevado
a la potencia “x”, es decir, x
e .

_______________________________________________________________________________________
139
pow(x, y): devuelve el valor de “x” elevado a la potencia “y”, es decir, y
x .
fabs(x): retorna el valor absoluto de “x”.
Veamos un ejemplo de programación para el uso de funciones trigonométricas, basados en
el diagrama esquemático de la figura 4.1:
Figura 4.1
Ejemplo para el calculo del sin(x), donde x = -0.5
program Trigon
Dim X As Float ' Variable del tipo punto flotante.
Y As Float ' Variable del tipo punto flotante.
txt As String[11] ' Arreglo tipo string para visualizar datos en pantalla.

_______________________________________________________________________________________
140
' Fin de la configuración de coneciones
X = -0.5 ' Cargamos el valor de X en la variable.
Y = Sin(X) ' Calculamos el seno de "X", el resultado se carga
' en la variable "Y".
floatToStr(Y, txt) ' Convertimos el resultado de Float a String para
' mostrarlo en la pantalla LCD.
' A continuación escribimos los resultados en la pantalla LCD:
Lcd_Out(1, 1, "Trigon. sin(x): ")
Lcd_Out(2, 1, "sin(0.5)=")
Lcd_Out(2, 10, txt)
End.
El resultado:
Figura 4.2

_______________________________________________________________________________________
141
4.1.2.- Ejemplo de programación #31: Ejemplo para el calculo del cos(x), donde x = 1.
program Trigon
X = 1 ' Cargamos el valor de X en la variable.
Y = Cos(X) ' Calculamos el coseno de "X", el resultado se carga
Lcd_Out(1, 1, "Trigon. cos(x): ")
Lcd_Out(2, 1, "cos(1) = ")
Lcd_Out(2, 10, txt)
End.
El resultado:
Figura 4.3

_______________________________________________________________________________________
142
4.1.3.- Ejemplo de programación #32: Ejemplo para el calculo de la tan(x), donde x = 0.6.
program Trigon
X = 0.6 ' Cargamos el valor de X en la variable.
Y = tan(X) ' Calculamos la tangente de "X", el resultado se carga
Lcd_Out(1, 1, "Trigon. tan(x): ")
Lcd_Out(2, 1, "tan(0.6)=")
Lcd_Out(2, 10, txt)
End.
El resultado:
Figura 4.4

_______________________________________________________________________________________
143
4.1.4.- Ejemplo de programación #33: En el siguiente ejemplo de programación
realizaremos un programa para el control de una calculadora sencilla, cuya función principal
será realizar las siguientes operaciones en base a dos valores introducidos desde un
teclado:
Suma.
Resta.
Multiplicación.
División.
Raíz Cuadrada de un valor.
El procedimiento para realizar una operación en la calculadora es el siguiente:
1. Ingresamos el primer valor de la operación.
2. Pulsamos el botón correspondiente al tipo de operación: + - * /
3. Ingresamos el segundo valor de la operación.
4. Pulsamos el botón de "Igualdad" para obtener el resultado.
En el caso del cálculo de la raíz cuadrada de un número:
1. Ingresamos el valor de la operación.
2. Pulsamos el botón correspondiente al cálculo de la raíz cuadrada “Sqrt”.
Si deseamos realizar una nueva operación, se deberá pulsar el botón de “Reset” del circuito
para inicializar todo el programa.
Analice y lea detenidamente los comentarios realizados en cada línea del programa, ya que
la explicación del procedimiento de cálculo se encuentra a lo largo de todo el cuerpo del
programa.
El ejemplo está basado en el diagrama esquemático de la figura 4.5. El microcontrolador
elegido para este ejemplo ha sido el PIC18F442. Se debe tomar en cuenta que cada botón
en el teclado deberá tener la configuración mostrada en el recuadro que contiene un
pulsador con una resistencia “Pull Down”.

_______________________________________________________________________________________
144
Figura 4.5
program calculadora
Dim pulsador As Byte ' Variable para almacenar el resultado de
' la rutina "keypad".
txt As String[25] ' Variable para la conversión de Byte a String.
Digito As Byte[15] ' Arreglo para almacenar los digitos introducidos desde
' cada pulsador.
Valor As Float[3] ' Variable tipo punto flotante para almacenar cada valor
' de una operación, ejemplo, si la operación es una suma:
' 5485 + 3654 = Resultado, entonces almacenaremos 5485 en
' la variable "Valor[1]" y 3654 en la variable "Valor[2]"
Operacion As Byte ' Para determinar que tipo de operación vamos a hacer
' con los valores, es decir, si Operación = 1 será una
' suma; si Operación = 2 será una resta; si Operación = 3
' será una multiplicación; si Operación = 4 será una
' división.
Resultado As Float ' Variable tipo punto flotante para almacenar el Resultado

_______________________________________________________________________________________
145
' de una operación matemática. Es Punto Flotante ya que en
' algunos operaciones vamos a obtener un resultado con no
' entero, o con decimales. Ejemplo: 45 / 2 = 22.50
I As Byte ' Variable para controlar el indice del arrego "Digito[n]"
X As Byte ' Variable para controlar el indice del arreglo "Valor[n]"
Operacion = 0 ' Inicializamos la variable "Operacion"
pulsador = 0 ' Inicializamos la variable "Pulsador"
I = 1 ' Inicializamos el indice del arreglo Digito[n]
' en 1.
X = 1 ' Inicializamos el indice del arreglo Valor[n]
' en 1.
Valor[1] = 0 ' Inicializamos la variable Valor[1]
Valor[2] = 0 ' Inicializamos la variable Valor[2]
Lcd_Out(1, 1, "Calculadora: ") ' Escribimos un mensaje en la pantalla.
Lcd_Out(2, 1, " ")
inicio:
GoTo Teclado ' Llamamos a la subrutina "Teclado" para verificar si alguno de
' los pulsadores ha sido presionado.
' Cada dígito que introducimos desde el Teclado para un Valor de la operación
' matemática que deseamos realizar, es almacenado en el arreglo Digito[n],
' iniciando desde Digito[1], es decir, si quisieramos hacer una suma:
'
' 1521 + 50 = Resultado.
'
' los dígitos del primer valor (1500) se almacenarán en las variables:
' Digito[1] = 1, Digito[2] = 5, Digito[3] = 2 y Digito[4] = 1
'
' Es muy importante recordar que el procedimiento para realizar una operación en
' una calculadora común, es el siguiente:
'
' 1ro.- Ingresamos el primer valor de la operación.
' 2do.- Pulsamos el botón correspondiente al tipo de operación: + - * /
' 3ro.- Ingresamos el segundo valor de la operación.
' 4to.- Pulsamos el botón de "Igualdad" para obtener el resultado.
'
' Cada vez que introducimos un nuevo dígito, incrementamos el indice de referencia
' del arreglo Digito[I], es decir, I = I + 1. De esta forma nos aseguramos que
' cada dígito de un valor de la operación queda almacenado en su propia variable.
'
' Luego para llevar este valor (1500) a una sola variable de tipo punto flotante,

_______________________________________________________________________________________
146
' realizamos la siguiente operación:
'
' Si I = 1, osea, si solo hemos introducido un digito, entonces:
' Valor[1] = Digito[1] = 1
'
' Si I = 2, entonces hemos introducido un segundo digito:
' Valor[1] = (Digito[1] * 10) + Digito[2]), con valores sería:
' Valor[1] = ( 1 * 10) + 5 ) = 15
'
' Si I = 3, entonces hemos introducido un tercer digito:
' Valor[1] = ((Digito[1] * 100) + (Digito[2] * 10) + Digito[3]), con valores sería:
' Valor[1] = (( 1 * 100) + ( 5 * 10) + 2 ) = 152
'
' Si I = 4, entonces hemos introducido un cuarto digito:
' Valor[1] = ((Digito[1] * 1000) + (Digito[2] * 100) + (Digito[3] * 10) + Digito[4])
' Valor[1] = (( 1 * 1000) + ( 5 * 100) + ( 2 * 10) + 1)
' Valor[1] = 1521
' La siguiente subrutina, realiza este cálculo hasta el dígito numero nueve de un
' valor, y los cálculos de la explicación que acabamos de ver se realizan diferente
' pero generan el mismo resultado. Analice cómo se realiza el cálculo del valor[1] a
' continuación:
sigue:
If I = 1 Then ' Si I = 1, significa que hemos introducido el
' primer dígito del Valor, entonces, Valor[X] será igual
Valor[X] = Digito[1] ' al valor cargado en Digito[1] en la subrutina "Teclado".
End If
If I = 2 Then ' Significa que hemos introducido un segundo dígito.
Digito[1] = Digito[1] * 10
Valor[X] = Digito[1] + Digito[2]
End If
If I = 3 Then ' Significa que hemos introducido un tercer dígito.
Valor[X] = Valor[X] * 10
Valor[X] = Valor[X] + Digito[3]
End If
If I = 4 Then ' Significa que hemos introducido un cuarto dígito.
End If
If I = 5 Then ' Significa que hemos introducido un quinto dígito.
End If
If I = 6 Then ' Significa que hemos introducido un sexto dígito.
End If
If I = 7 Then ' Significa que hemos introducido un septimo dígito.
End If
If I = 8 Then ' Significa que hemos introducido un octavo dígito.
End If
If I = 9 Then ' Significa que hemos introducido un noveno dígito.
End If
I = I + 1 ' Incrementa el indice del arreglo "Digito[n]" cada
' vez que introducimos un dígito.
' A medida que vamos introduciendo dígitos al valor deseado para la operación

_______________________________________________________________________________________
147
' matemática, es bueno ir mostrando los mismos en la pantalla LCD:
WordToStr(Valor[X], txt) ' Convertimos el valor actual de "Valor[X]" en string.
Lcd_Out(1, 1, "Calculadora: ") ' Mostramos el mensaje en pantalla.
Lcd_Out(2, 1, txt) ' Mostramos el valor convertido.
GoTo inicio ' Salta a inicio para esperar un nuevo dígito.
Suma: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Suma" conectada al
' pin RD2 del puerto "D" del microcontrolador. Cuando llegamos a esta
' subrutina, significa que ya hemos terminado de introducir los dígitos
' de la variable "Valor[1]", por lo tanto, lo que hacemos en adelante es
' mantener en memoria qué tipo de operación deseamos realizar a través
' de la asignación de un valor cargado en la variable "Operación" el cual
' se corresponderá al tipo de operación asignada.
Operacion = 1 ' 1 nos indicará que deberemos sumar Valor[1] y Valor[2].
I = 1 ' Inicializamos el indice del arreglo Digito[n], ya que en adelante
' estas variables serán utilizadas para almacenar los dígitos del
' segundo valor de la operación matemática.
X = 2 ' X = 2 debido a que el resultado de introducir los dígitos del
' segundo valor de la operación será almacenado en "Valor[2]".
Lcd_Out(1, 1, "Calculadora: + ") ' Anunciamos el tipo de operación en la LCD,
Lcd_Out(2, 1, " ") ' en este caso se observa que hemos agregado
' el símbolo "+".
GoTo inicio ' Salta a la etiqueta "inicio" para recibir los digitos del
' segundo valor de la operación matemática.
Resta: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Resta" conectada al
' pin RD3 del puerto "D" del microcontrolador.
Operacion = 2 ' 2 nos indicará que deberemos restar Valor[1] y Valor[2].
I = 1
X = 2
Lcd_Out(1, 1, "Calculadora: - ")
Lcd_Out(2, 1, " ")
GoTo inicio
Multiplica: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Mult." conectada
' al pin RD4 del puerto "D" del microcontrolador.
Operacion = 3 ' 3 nos indicará que deberemos multiplicar Valor[1] y Valor[2].
I = 1
X = 2
Lcd_Out(1, 1, "Calculadora: X ")
Lcd_Out(2, 1, " ")
GoTo inicio
Divide: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Div." conectada al
' pin RD5 del puerto "D" del microcontrolador.
Operacion = 4 ' 4 nos indicará que deberemos dividir Valor[1] y Valor[2].
I = 1
X = 2
Lcd_Out(1, 1, "Calculadora: / ")
Lcd_Out(2, 1, " ")
GoTo inicio
RaizCuadrada: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Sqrt"
' conectada al pin RD6 del puerto "D" del microcontrolador.

_______________________________________________________________________________________
148
Resultado = Sqrt(Valor[1]) ' Calcula la raiz cuadrada de Valor[1] y almacena
' el resultado en la variable.
FloatToStr(Resultado, txt) ' Convierte el resultado en un string para poder
Lcd_Out(1, 1, "Calculadora:Sqrt") ' Especificamos el tipo de operación.
Lcd_Out(2, 1, txt) ' Mostramos el resultado en la pantalla LCD.
GoTo Fin ' Salta a la rutina de Lazo Infinito.
Igualdad: ' Esta subrutina se ejecuta cuando pulsamos la tecla "Igualdad"
' conectada al pin RD7 del puerto "D" del microcontrolador.
' En esta rutina es cuando identificamos el tipo de operación (+ - * /) que
' deseamos para los dos valores cargados en Valor[1] y Valor[2].
' Si Operacion = 1 entonces Suma los dos valores.
If Operacion = 1 Then
Resultado = Valor[1] + Valor[2]
End If
' Si Operacion = 2 entonces Resta los dos valores.
Resultado = Valor[1] - Valor[2]
End If
' Si Operacion = 3 entonces Multiplica los dos valores.
Resultado = Valor[1] * Valor[2]
End If
' Si Operacion = 4 entonces Divide los dos valores.
Resultado = Valor[1] / Valor[2]
End If
FloatToStr(Resultado, txt) ' Convierte el resultado en un string para poder
Lcd_Out(1, 1, "Calculadora: = ") ' Especificamos el tipo de operación.
Lcd_Out(2, 1, txt) ' Mostramos el resultado en la pantalla LCD.
Fin: GoTo Fin ' Lazo Infinito. Si deseamos realizar una nueva operación matemática
' entoces debemos reiniciar el microcontrolador a través del pulsador
' "Reset" del circuito.
' La siguiente subrutina se encarga de verificar si uno de los pulsadores en el
' circuito ha sido presionado.
'
' Cuando un pulsador es presionado, se carga el valor correspondiente a la tecla
' en la variable "Digito[I]".
Teclado:
If Button(PortC, 0, 150, 1) Then
Digito[I] = 1
GoTo sigue
End If
Digito[I] = 2
GoTo sigue
End If
Digito[I] = 3
GoTo sigue
End If

_______________________________________________________________________________________
149
Digito[I] = 4
GoTo sigue
End If
Digito[I] = 5
GoTo sigue
End If
Digito[I] = 6
GoTo sigue
End If
Digito[I] = 7
GoTo sigue
End If
Digito[I] = 8
GoTo sigue
End If
If Button(PortD, 0, 150, 1) Then
Digito[I] = 9
GoTo sigue
End If
Digito[I] = 0
GoTo sigue
End If
' Los siguientes pulsadores están asignados para realizar un salto a las
' subrutinas correspondientes a la operación matemática deseada:
' Si pulsamos el botón "Suma", entonces el programa salta a la subrutina "Suma":
GoTo Suma
End If
' Si pulsamos el botón "Resta", entonces el programa salta a la subrutina "Resta":
GoTo Resta
End If
' Si pulsamos el botón "Mult.", entonces el programa salta a la subrutina "Multiplicacion":
GoTo Multiplica
End If
' Si pulsamos el botón de "Div.", entonces el programa salta a la subrutina "Divide":
GoTo Divide
End If
' Si pulsamos el botón "Sqrt", entonces el programa salta a la subrutina "RaizCuadrada":
GoTo RaizCuadrada
End If
' Si pulsamos el botón "Igualdad", entonces el programa salta a la subrutina "Igualdad":
GoTo Igualdad
End If

_______________________________________________________________________________________
150
GoTo inicio ' Salta a la etiqueta incio.
End.
Al ejecutar el programa anterior, podremos ver en la pantalla LCD el siguiente mensaje:
Figura 4.6
En este punto, el programa está listo para recibir los dígitos del primer valor. Veamos un
ejemplo de una operación matemática:
1521 + 50 = 1571.00000
Ingresamos el primer valor:
Figura 4.7

_______________________________________________________________________________________
151
Seguidamente elegimos en el teclado el tipo de operación:
Figura 4.8
Ingresamos el segundo valor:
Figura 4.9
Por último, pulsamos la tecla de igualdad para visualizar el resultado:
Figura 4.10

_______________________________________________________________________________________
152
Capítulo V. Librería Sound
5.1.- Rutinas de la librería de sonido de mikroBasic.
A través de esta librería, mikroBasic nos facilita la generación de sonidos de frecuencias
predefinidas y con una duración que podemos especificar fácilmente. Esta librería cuenta
con dos únicas rutinas:
Sound_Init(Puerto, Pin).
Sound_Play(Frecuencia, Duración).
Estas dos rutinas son muy intuitivas por lo cual será muy sencillo visualizar un diseño que
genere tonos audibles para el oído humano.
Un ejemplo práctico y útil para demostrar el uso de esta librería, será crear un programa
capaz de generar las frecuencias correspondientes a la escala de notas musicales universal:
Do Do# Re Re# Mi Fa Fa# Sol Sol# La La# Si
Figura 5.1

_______________________________________________________________________________________
153
Acerca de las notas musicales, existe un convenio mundial en el cual se toma la nota “LA”
como nota de referencia o como nota para afinar instrumentos musicales, y cuya frecuencia
es de 440 Hz. Este convenio ha determinado el uso de frecuencias específicas
denominadas “notas”, y este arreglo de frecuencias a su vez ha sido dividido en intervalos
denominados “octavas”. Cada “octava” se compone de 12 notas musicales. Las notas que
tienen el símbolo # en la figura 5.1 se denominan semitonos o bemoles.
La nota de referencia “La”, se encuentra en la “octava” A4, cuyas 12 frecuencias
especificaremos a continuación y las cuales utilizaremos como punto de partida para la
generación de tonos de una escala musical.
Una formula matemática para obtener las frecuencias de las notas musicales a partir de una
nota de referencia, ha sido la de multiplicar la frecuencia de dicho tono por la raíz duodécima
de 2, es decir, por 1,05945454545.
Esto significa que si deseamos hallar la frecuencia para la nota inmediatamente superior a la
nota de referencia “La”, la formula matemática correspondiente para calcular este valor seria
la siguiente:
15
.
466
059454545
.
1
440
2
440
# 12
Hz
La Hz
Si deseáramos hallar la nota inmediatamente inferior a la nota de referencia “L”, entonces la
formula matemática para calcular este valor sería la siguiente:
30
.
415
059454545
.
1
440
2
440
# 12
Hz
Hz
La Hz
Entonces, realizando los cálculos para todas las notas de la “octava” A4, tenemos que:
Nota Frecuencia
Do 261.64 Hz
Do# 277.20 Hz
Re 293.68 Hz
Re# 311.14 Hz
Mi 329.64 Hz
Fa 349.24 Hz
Fa# 370.00 Hz
Sol 392.00 Hz
Sol# 415.30 Hz
La 440.00 Hz
La# 466.15 Hz
Si 493.86 Hz
Figura 5.2

_______________________________________________________________________________________
154
Veamos como reproducir el sonido que cada nota de la figura 5.1 a través de un programa
en mikroBasic, el cual esta diseñado en base al diagrama esquemático de la figura 5.3:
Figura 5.3
En el siguiente programa de ejemplo, hemos declarado los valores de las frecuencias
correspondientes a cada nota principal de la octava A4 como constantes (No se
reproducirán los semitonos en este ejemplo, por lo tanto no se declaran). Estos valores
serán visualizados en la pantalla LCD mientras cada una de las notas es reproducida a
través del parlante o “Speaker” conectado al pin RD0 del puerto “D”. Recuerde verificar que
la librería “Sound” ha sido seleccionada para su proyecto para no tener errores al momento
de compilar este ejemplo.
program Sound1

_______________________________________________________________________________________
155
txt As String[6] ' Variable de contenido temporal tipo String
' Frecuencias de notas principales de la "octava" A4:
Const nota_Do = 261.64 ' Nota "Do" de cuarta octava musical.
Const nota_Re = 293.68
Const nota_Mi = 329.64
Const nota_Fa = 349.24
Const nota_Sol = 392.00
Const nota_La = 440.00
Const nota_Si = 493.86
Const nota_Do5 = 523.28 ' Nota "Do" de quinta octava musical.
main:
LCD_Init()
Sound_Init(PORTD, 0) ' Asignamos el pin RD0 para generar los tonos.
FloatToStr(nota_Do, txt) ' Convertimos la constante "nota_Do" en un "string"
Lcd_Out(1, 1, "Nota Do: ") ' Visualizamos el mensaje correspondiente en la LCD.
Lcd_Out(1, 10, txt) ' Se imprime el contenido de la variable "txt"
Sound_Play(nota_Do, 500) ' Se reproduce el sonido correspondiente a la nota
' durante 500 milisegundos.
FloatToStr(nota_Re, txt) ' Convertimos la constante "nota_Re" en un "string"
Lcd_Out(1, 1, "Nota Re: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Re, 500) ' Se reproduce el sonido correspondiente a la nota
FloatToStr(nota_Mi, txt) ' Convertimos la constante "nota_Mi" en un "string"
Lcd_Out(1, 1, "Nota Mi: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Mi, 500) ' Se reproduce el sonido correspondiente a la nota
FloatToStr(nota_Fa, txt) ' Convertimos la constante "nota_Fa" en un "string"
Lcd_Out(1, 1, "Nota Fa: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Fa, 500) ' Se reproduce el sonido correspondiente a la nota
FloatToStr(nota_Sol, txt) ' Convertimos la constante "nota_Sol" en un "string"
Lcd_Out(1, 1, "Nota Sol: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Sol, 500) ' Se reproduce el sonido correspondiente a la nota
FloatToStr(nota_La, txt) ' Convertimos la constante "nota_La" en un "string"
Lcd_Out(1, 1, "Nota La: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_La, 500) ' Se reproduce el sonido correspondiente a la nota

_______________________________________________________________________________________
156
FloatToStr(nota_Si, txt) ' Convertimos la constante "nota_Si" en un "string"
Lcd_Out(1, 1, "Nota Si: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Si, 500) ' Se reproduce el sonido correspondiente a la nota
FloatToStr(nota_Do5, txt) ' Convertimos la constante "nota_Do5" en un "string"
Lcd_Out(1, 1, "Nota Do5: ") ' Visualizamos el mensaje correspondiente en la LCD.
Sound_Play(nota_Do5, 500) ' Se reproduce el sonido correspondiente a la nota
End.
Para reproducir una octava superior a esta (A4), bastará con multiplicar por 2 el valor de las
frecuencias de ésta, entonces estaremos reproduciendo los tonos correspondientes a una
quinta octava. Esto infiere que si deseamos oír los tonos correspondientes a una sexta
octava, entonces podríamos multiplicar la octava A4 por 3, o la quinta octava por 2.
Constantes para la octava A4 completa:
' Frecuencias de notas de la "octava" A4:
Const nota_DoB = 277.20
Const nota_ReB = 311.14
Const nota_FaB = 370.00
Const nota_SolB = 415.30
Const nota_LaB = 466.15
Constantes para la quinta octava:
' Frecuencias de notas de la quinta "octava":
Const nota_Do = 261.64 * 2 ' Nota "Do" de quinta octava musical.
Const nota_DoB = 277.20 * 2
Const nota_Re = 293.68 * 2
Const nota_ReB = 311.14 * 2
Const nota_Mi = 329.64 * 2
Const nota_Fa = 349.24 * 2
Const nota_FaB = 370.00 * 2
Const nota_Sol = 392.00 * 2
Const nota_SolB = 415.30 * 2
Const nota_La = 440.00 * 2
Const nota_LaB = 466.15 * 2
Const nota_Si = 493.86 * 2

_______________________________________________________________________________________
157
El siguiente ejercicio es la representación de un pequeño piano con una “octava” A4
completa. En este caso hemos eliminado la pantalla LCD y hemos agregado 12 pulsadores
los cuales estarán conectados a los puertos C y D del microcontrolador PIC. Observe que el
parlante ha sido conectado en el pin RD7.
Figura 5.4

_______________________________________________________________________________________
158
Analice el siguiente programa, leyendo detenidamente los comentarios en cada línea.
program Piano
' Frecuencias de notas principales de la "octava" A4:
Const nota_DoB = 277.20
Const nota_ReB = 311.14
Const nota_FaB = 370.00
Const nota_SolB = 415.30
Const nota_LaB = 466.15
main:
TRISC = $FF ' Configuración de pines del puerto C.
TRISD = $7F ' Configuración de pines del puerto D.
Sound_Init(PORTD, 7) ' Asignamos el pin RD7 para generar los tonos.
If Button(PortC, 0, 50, 1) Then ' Verificamos si "Do" fue presionado, estado activo = 1.
Sound_Play(nota_Do, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 1, 50, 1) Then ' Verificamos si "Do#" fue presionado, estado activo = 1.
Sound_Play(nota_DoB, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 2, 50, 1) Then ' Verificamos si "Re" fue presionado, estado activo = 1.
Sound_Play(nota_Re, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 3, 50, 1) Then ' Verificamos si "Re#" fue presionado, estado activo = 1.
Sound_Play(nota_ReB, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 4, 50, 1) Then ' Verificamos si "Mi" fue presionado, estado activo = 1.
Sound_Play(nota_Mi, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 5, 50, 1) Then ' Verificamos si "Fa" fue presionado, estado activo = 1.
Sound_Play(nota_Fa, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 6, 50, 1) Then ' Verificamos si "Fa#" fue presionado, estado activo = 1.
Sound_Play(nota_FaB, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortC, 7, 50, 1) Then ' Verificamos si "Sol" fue presionado, estado activo = 1.
Sound_Play(nota_Sol, 200) ' Se reproduce el sonido correspondiente a la nota

_______________________________________________________________________________________
159
End If
If Button(PortD, 0, 50, 1) Then ' Verificamos si "Sol#" fue presionado, estado activo =
1.
Sound_Play(nota_SolB, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortD, 1, 50, 1) Then ' Verificamos si "La" fue presionado, estado activo = 1.
Sound_Play(nota_La, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortD, 2, 50, 1) Then ' Verificamos si "La#" fue presionado, estado activo = 1.
Sound_Play(nota_LaB, 200) ' Se reproduce el sonido correspondiente a la nota
End If
If Button(PortD, 3, 50, 1) Then ' Verificamos si "Si" fue presionado, estado activo = 1.
Sound_Play(nota_Si, 200) ' Se reproduce el sonido correspondiente a la nota
End If
GoTo main
End.

_______________________________________________________________________________________
160
Capítulo VI. Teclado Matricial y Teclado PS/2
6.1.- Teclado Matricial.
Para introducir datos de forma manual en un microcontrolador, nada mejor que un teclado
matricial para este fin. Los teclados matriciales más comunes son de 3 columnas por 4 filas,
y de 4 columnas por 4 filas, como los mostrados en la figura 6.1:
Figura 6.1
Figura 6.2
El principio de funcionamiento de un teclado matricial es muy sencillo. Básicamente cuando
pulsamos un botón en el teclado, estamos uniendo una fila con una columna.

_______________________________________________________________________________________
161
Por ejemplo, al presionar la tecla “1”, estaremos conectando la columna 1 con la fila 1; si
pulsamos la tecla “4”, estaremos conectando nuevamente la columna 1, esta ves con la fila
2; si pulsamos la tecla “9”, entonces estaremos conectando la columna 3 con la fila 3.
Existen diversas formas de conectar e interpretar el funcionamiento de un teclado matricial.
En el diagrama de la figura 6.4 se puede apreciar un teclado matricial 4x4 conectado a los
pines del puerto D, los cuales se han distribuido y configurado de la siguiente manera:
Puerto D Teclado 4x4
RD0 Columna 1
RD1 Columna 2
RD2 Columna 3
RD3 Columna 3
RD4 Fila 1
RD5 Fila 2
RD6 Fila 3
RD7 Fila 4
Figura 6.3
Los pines RD0, RD1, RD2 y RD3 correspondientes a las columnas se comportan como
entradas, y los pines RD4, RD5, RD6 y RD7 correspondientes a las filas se comportan como
salidas.
Observe en el diagrama esquemático, que los pines RD0, RD1, RD2 y RD3 tienen una
resistencia “Pull-Down” de 10 Kohm, lo cual significa que si leemos cualquiera de estas
entradas, asumiendo que ninguna tecla ha sido presionada, entonces siempre habrá un cero
lógico (0) presente en cada una de ellas.

_______________________________________________________________________________________
162
Figura 6.4
En la primera edición del libro “Basic para microcontroladores PIC”, analizar un teclado
matricial para saber cual de las teclas había sido presionada, requería de una serie de pasos
en los cuales debíamos enviar un pulso a través de cada salida del puerto en el cual se
encontraba conectado el teclado matricial y seguidamente preguntar en cada una de las
entradas si el estado lógico presente había cambiado, de tal manera que pudiésemos
reconocer cual de las teclas en ese instante había sido presionada.
Con mikroBasic, la tarea del análisis de un teclado matricial ha sido simplificada de tal
manera a través de su librería “KeyPad”, que tan solo requerimos de una sola rutina para
capturar el dato que identificará a la tecla presionada en un determinado momento. Por
supuesto, antes de utilizar esta rutina, siempre es importante inicializar el puerto en el cual
estaremos conectando el teclado.

_______________________________________________________________________________________
163
Los primeros ejercicios los estaremos programando en base al diagrama esquemático de la
figura 6.4, por lo tanto el puerto de conexión del teclado será el puerto D del
microcontrolador PIC16F877.
Antes de empezar, debemos recordar verificar que hemos seleccionado las librerías
correspondientes a los periféricos que tenemos conectados al microcontrolador. En este
caso, la pestaña de librerías del proyecto se debería ver de la siguiente forma:
Figura 6.5

_______________________________________________________________________________________
164
6.2.- Librería KeyPad.
La configuración del puerto correspondiente al teclado matricial se debe hacer de la
siguiente manera:
dim keypadPort as byte at PORTC
Como en otros capítulos, esta línea de programación se hace al inicio del programa, en la
sección de declaración de variables. Esta línea es muy importante, ya que sin ella el
compilador no podrá determinar en cual de los puertos del microcontrolador estará ubicado
el teclado matricial.
Lo siguiente a tomar en cuenta será la rutina de inicialización para el teclado matricial. Esta
rutina inicializa el puerto elegido para que sea capaz de trabajar con el teclado.
6.2.1.- Keypad_Init().
Una vez inicializado el puerto, solo nos queda preguntar en el programa si alguna de las
teclas ha sido presionada, y si ese fuese el caso, cual es el valor correspondiente de ésta
para cargarlo en una variable y poder visualizarlo en la pantalla LCD.
En el siguiente ejemplo podremos ver la rutina encargada de extraer el dato correspondiente
a la tecla presionada en el teclado en un determinado momento. Este paso es posible
gracias a la siguiente rutina.
6.2.2.- Keypad_Key_Press().
El dato correspondiente a la tecla presionada se cargará en una variable tipo “Byte”
previamente declarada. Por ejemplo:
Dim Pulsador As Byte
Pulsador = Keypad_Key_Press()
Cuando el microcontrolador procesa esta línea (asumiendo que hemos conectado un teclado
matricial de 4 filas por 4 columnas), un valor entre 1 y 16 es cargado en la variable
“Pulsador”.

_______________________________________________________________________________________
165
Figura 6.6
Estos valores se corresponden con las teclas de la siguiente manera:
Tecla Presionada Valor cargado en la variable
1 1
2 2
3 3
A 4
4 5
5 6
6 7
B 8
7 9
8 10
9 11
C 12
* 13
0 14
# 15
D 16
Figura 6.7
Un dato importante a considerar sobre esta rutina, es que el valor es cargado en la variable
justo cuando presionamos la tecla, a diferencia de la siguiente rutina, que carga el valor en
la variable cuando liberamos la tecla:
Dim Pulsador As Byte
Pulsador = Keypad_Key_Click()

_______________________________________________________________________________________
166
Veamos a continuación el programa que captura el valor correspondiente a una tecla
presionada. El resultado cargado en la variable se verá en la pantalla LCD.
program Proyecto_KeyPad_01
Dim keypadPort As Byte At PORTD ' Declaramos en puerto en el cual estará
' conectado el Teclado matricial.
pulsador As Byte ' Variable para almacenar el resultado de
pulsadorStr As String[5] ' Variable para la conversión de Byte a String.
inicio:
GoSub Teclado ' Llamamos a la subrutina del Teclado.
byteToStr(pulsador, pulsadorStr) ' Convertimos el resultado a "String".
Lcd_Out(1, 1, "Tecla:") ' Escribimos la palabra "Tecla:"
Lcd_Out(1, 7,pulsadorStr) ' Imprime el resultado de la rutina KeyPad.
GoTo inicio ' Saltamos a la etiqueta "inicio".
Teclado:
pulsador = Keypad_Key_Press() ' Si un pulsador ha sido, captura el valor
' decimal correspondiente a éste.
Return ' Retorna una línea despues del llamado a la
' rutina "teclado".
End.

_______________________________________________________________________________________
167
Al compilar y grabar el programa en el microcontrolador, el resultado mientras ninguna tecla
haya sido presionada será el siguiente:
Figura 6.8
A presionar cada una de las teclas, el resultado deberá corresponder a la tabla de la figura
6.7.
Observe que el valor de la tecla presionada efectivamente se mantiene en pantalla mientras
la tecla se encuentra en ese estado.
Si deseáramos cargar el valor correspondiente a la tecla en la variable “Pulsador” al soltar la
tecla, entonces la subrutina “teclado” deberá verse de la siguiente manera:
Teclado:
pulsador = Keypad_Key_Click() ' Si un pulsador ha sido, captura el valor
' rutina "teclado".
Analizando el programa, podemos observar que primero hemos hecho lo necesario para
configurar los puertos de conexión entre el microcontrolador y los periféricos, además de la
declaración de dos variables, una para almacenar el dato obtenido desde el teclado matricial
y la otra para realizar la conversión del contenido de la primera variable de “byte” a “string”,
de tal manera que podamos mostrar en resultado en la pantalla LCD.
Luego inicializamos la pantalla LCD, limpiamos la pantalla y apagamos el cursor y por
último, hacemos un llamado con retorno a la subrutina “teclado” la cual extraerá el valor
correspondiente si es que hay alguna tecla presionada, para luego regresar y mostrar el dato
en la pantalla LCD haciendo la respectiva conversión del dato cargado en la variable
“Pulsador”.
Es de esta manera que podremos ver un valor en la pantalla LCD entre 1 y 16, cada uno de
ellos correspondientes a un pulsador en un teclado matricial 4 x 4. Pero estos valores que
estamos mostrando en pantalla no necesariamente se corresponden con los valores o letras
impresas sobre cada tecla. Veamos de nuevo la figura del teclado y cómo está identificada
cada tecla:

_______________________________________________________________________________________
168
Figura 6.9
La asociación de valores versus teclas de la tabla de la figura 6.7 pudiera ser confusa a la
hora de realizar un programa, ya que sólo la identificación en las tres primeras teclas se
corresponde con el valor que vamos a obtener de la rutina “Keypad”, ya que cuando
presionamos la cuarta tecla, en vez de ver una “A” en la pantalla, estaremos viendo un “4”
como valor correspondiente a esta tecla.
Lo mismo ocurre para el resto de las teclas, por ejemplo, la siguiente tecla en el orden que
corresponde a los valores capturados por la rutina “Keypad” sería la tecla identificada con el
número “4” sobre ella, pero el valor correspondiente a ella cargado en la variable es el
número “5”, y esto continúa igual para el resto de las teclas hasta la última, identificada en
este caso con la letra “D” y cuyo valor correspondiente a ser cargado en la variable es igual
a “16”.
Para evitar confusiones al respecto a la hora de querer mostrar en pantalla cual de las teclas
ha sido presionada, lo que haremos será enmascarar en valor obtenido por la rutina
“Keypad”, de manera tal que podamos ver la identificación sobre la tecla y no el valor
capturado correspondiente a cada una de ellas.

_______________________________________________________________________________________
169
program Proyecto_KeyPad_02
inicio:
GoSub Teclado ' Llamamos a la subrutina del Teclado.
' Enmascaramos los valores de las teclas con el equivalente ASCII del valor
' o letra impresa sobre cada tecla:
' Abra la tabla Ascii Chart desde el menú "Tools" para comparar.
If pulsador = 0 Then
pulsador = 160 ' 49 en Ascii es " "
End If
pulsador = 49 ' 49 en Ascii es "1"
End If
End If
End If
pulsador = 65 ' 65 en Ascii es "A"
End If

_______________________________________________________________________________________
170
End If
End If
End If
pulsador = 66 ' 66 en Ascii es "B"
End If
End If
End If
End If
pulsador = 67 ' 67 en Ascii es "C"
End If
pulsador = 42 ' 42 en Ascii es "*"
End If
End If
pulsador = 35 ' 35 en Ascii es "#"
End If
pulsador = 68 ' 68 en Ascii es "D"
End If
Lcd_Out(1, 1, "Tecla:") ' Escribimos la palabra "Tecla:"
Lcd_Chr(1, 8, pulsador) ' Imprime el caracter Ascii del valor en la variable.
GoTo inicio ' Saltamos a la etiqueta "inicio".
Teclado:
' rutina "teclado".
End.

_______________________________________________________________________________________
171
De esta forma podremos ver el valor o letra impresa sobre cada tecla, es decir, si
presionamos la tecla “A”, veremos esta misma en la pantalla:
Figura 6.10
Si presionamos la tecla “*”, veremos este mismo símbolo en la pantalla:
Figura 6.11
Si presionamos la tecla “#”, veremos este mismo símbolo en la pantalla:
Figura 6.12
Lo mismo aplica para resto de las teclas.

_______________________________________________________________________________________
172
6.3.- Teclado PS/2.
MikroBasic posee una librería para el control de un teclado QWERTY - PS/2, a través del
cual podremos introducir datos a nuestros proyectos. Al igual que muchas de las librerías
anteriormente estudiadas, posee una rutina de inicialización y una rutina de captura de datos
para el teclado.
Figura 6.13
Básicamente la librería “PS/2” resuelve la comunicación entre el microcontrolador y un
teclado Qwerty en una sola vía, ya que sólo se utilizan dos líneas denominadas “Data” t Clk”.
Esto significa que cuando presionamos una tecla, la información de ésta es enviada hacia el
microcontrolador para ser procesada por el mismo (no hay comunicación desde el
microcontrolador hacia el teclado). Para que esta librería funcione correctamente, es
importante mencionar que el oscilador externo del microcontrolador debe ser igual o mayor a
6 Mhz. Otro punto importante a considerar será el uso de dos resistencias “Pull Up” en los
pines de comunicación del teclado, “data” y “Clk”.
Un teclado qwerty consta por lo regular de 101 teclas entre letras, números, símbolos o
teclas de funciones especiales. Cuando hacemos uso de esta librería, la rutina encargada de
realizar la comunicación y extracción de datos del teclado nos devuelve un valor numérico
que corresponderá a la tecla presionada, o dicho de otra manera, nos devolverá el valor
ASCII del símbolo correspondiente en la tecla; incluso es capaz de detectar mas de un
símbolo en una misma tecla, cuando hacemos uso de las funciones “Shift” o “Alt”.

_______________________________________________________________________________________
173
Una configuración común de un teclado Qwerty la podemos observar en la siguiente figura:
Figura 6.14
Los valores correspondientes a cada uno de los símbolos en un teclado estándar han sido
escritos en color rojo en la siguiente figura al lado derecho de cada símbolo, para tener una
referencia del valor ASCII en cada tecla.
Figura 6.15

_______________________________________________________________________________________
174
Los valores para las teclas de funciones especiales los podemos observar en la siguiente
tabla:
Tecla Valor
Retornado
F1 1
F2 2
F3 3
F4 4
F5 5
F6 6
F7 7
F8 8
F9 9
F10 10
F11 11
F12 12
Enter 13
Page Up 14
Page Down 15
Backspace 16
Insert 17
Delete 18
Windows 19
Ctrl 20
Shift 21
Alt 22
Print Screen 23
Pause 24
Caps Lock 25
End 26
Home 27
Scroll Lock 28
Num Lock 29
Left Arrow 30
Right Arrow 31
Up Arrow 32
Down Arrow 33
Escape 34
Tab 35
Figura 6.16. (Fuente: www.mikroe.com)

_______________________________________________________________________________________
175
Los ejemplos de programación estarán basados en el siguiente diagrama esquemático:
Figura 6.17
La identificación de los pines en un conector PS/2 con respecto al símbolo del mismo en el
diagrama esquemático se puede observar en la siguiente figura:
Figura 6.18 (Fuente: www.mikroe.com)

_______________________________________________________________________________________
176
6.4.- Librería PS/2.
Siempre será imprescindible realizar la declaración al inicio de un programa de los pines de
comunicación del teclado PS/2, como se muestra a continuación:
Dim PS2_Data As sbit At PORTC.0
Dim PS2_Clock As sbit At PORTC.1
Dim PS2_Data_Direction As sbit At TRISC.0
Dim PS2_Clock_Direction As sbit At TRISC.1
Se puede ver que en estas líneas han sido definidos los pines del puerto en el cual han sido
conectados los pines de comunicación del teclado, “Data” y Clk”. Esta definición se realizó
en base al diagrama esquemático propuesto anteriormente.
Adicionalmente a esto, la librería PS/2 cuenta con dos rutinas a través de las cuales
inicializamos el teclado y extraemos los datos:
Ps2_Config()
Ps2_Key_Read()
6.4.1.- Ps2_Config().
Esta rutina se encarga de inicializar el microcontrolador para trabajar con el teclado PS/2.
6.4.2.- Ps2_Key_Read(valor, función, estado)
Esta rutina tiene tres campos que hemos denominado “valor”, “especial” y “estado”.
Valor: almacena el valor correspondiente al símbolo en la tecla presionada.
Función: Es una bandera cuyo estado cambia entre 1 y 0, y nos indica si una tecla de
función especial ha sido presionada o no. Si una tecla de función especial ha sido
presionada, el estado de este campo será igual a 1.
Estado: Este campo será igual a 1 si una tecla ha sido presionada. Si no hay teclas
presionadas, este campo será igual a 0.
Para entender como funcionan estas dos rutinas, realizaremos un ejemplo de un programa
capaz de mostrar el valor ASCII de cada símbolo sobre el teclado en la pantalla LCD,
exceptuando los valores de las teclas de funciones especiales.

_______________________________________________________________________________________
177
Antes de empezar a programar, recordemos que cuando creamos un nuevo proyecto en
mikroBasic, siempre es importante verificar hemos seleccionado las librerías
correspondientes a los periféricos que estaremos utilizando en la práctica. En este caso, las
librerías a seleccionar deberán ser las siguientes:
Figura 6.19
Veamos el siguiente ejercicio:
program PS2_01
' Declaración de variables y puertos para Librería PS/2:
PS2_Clock As sbit At PORTC.1
PS2_Data_Direction As sbit At TRISC.0
PS2_Clock_Direction As sbit At TRISC.1

_______________________________________________________________________________________
178
Dim Valor, funcion, estado As Byte
Dim txt As String[4]
main:
LCD_Cmd(_LCD_CLEAR) ' Limpiamos la pantalla LCD.
LCD_Cmd(_LCD_CURSOR_OFF) ' Apagamos el Cursor.
Ps2_Config() ' Inicializamos MCU para comunicación con PS/2.
Delay_ms(100) ' Retardo de 100 milisegundos.
Lcd_Out(1, 1, "Caracter: ") ' Escribimos la palabra "Caracter:" en la primera línea.
Lcd_Out(2, 1, "ASCII: ") ' Escribimos la palabra "ASCII:" en la segunda línea
While TRUE
Ps2_Key_Read(Valor, funcion, estado) ' Verificamos si ha sido presionada una tecla.
' Seguidamente, verificamos el estado de cada campo o variable en la rutina,
' y entregamos un resultado sólo si se cumple la condición planteada:
' si el campo o variable "estado" es diferente de cero (lo cual significa que ha sido
' presionada una tecla), y...
' si el campo o variable "funcion" es igual a cero (lo cual significa que ninguna
' tecla de función especial ha sido presionada) y...
' si el campo o variable "valor" es diferente de cero... entonces:
If (estado <> 0) And (funcion = 0) And (Valor <> 0) Then
ByteToStr(Valor, txt) ' Convertimos la variable "valor" en un string de datos.
Lcd_Out(1, 11, txt) ' Mostramos el string de datos en la pantalla LCD, en la
' posición especificada, línea 1, columna 11.
LCD_Chr(2, 12, Valor) ' Mostramos el equivalente ASCII en la posición
' especificada, línea 2, columna 12.
End If
Delay_ms(10) ' Hacemos una pausa de 10 milisegundos.
Wend
End.
Analizando el programa detenidamente, podemos observar que gran parte del mismo solo
define la configuración de los dispositivos periféricos conectados al microcontrolador.
En primer lugar, se realizó la definición de pines para el conexionado del teclado PS/2
y la pantalla LCD. Luego hemos definido las variables necesarias para cargar los
datos capturados desde el teclado.
A partir de la etiqueta “main”, hacemos lo necesario para inicializar la pantalla LCD y
para preparar las comunicaciones entre el teclado y el microcontrolador. En este
punto es recomendable realizar una pausa de al menos 100 milisegundos, para dar
tiempo suficiente sobre la inicialización de los periféricos.

_______________________________________________________________________________________
179
Escribimos el texto que identificará los datos a ser mostrados en cada una de las
líneas de la pantalla LCD. En este ejemplo escribimos la palabra “Caracter:” en la
línea 1, columna 1; y la palabra “ASCII:” en la línea 2, columna 1 de la pantalla.
Realizamos el resto del programa en un ciclo infinito, en el cual estaremos
capturando los datos provenientes del teclado PS/2, para luego ser almacenados y
mostrados en la pantalla LCD.
Veamos los resultados de este ejercicio si presionamos la siguiente tecla de ejemplo:
Figura 6.20
Al presionar la tecla señalada por un círculo en la figura anterior, el resultado en la
pantalla deberá ser el siguiente:
Figura 6.21

_______________________________________________________________________________________
180
Pero si presionamos la tecla “Shift” o “Mayúscula” y luego la misma tecla señalada,
entonces el resultado cambia:
Figura 6.22
Lo mismo ocurrirá si presionamos cualquier otra tecla, siempre y cuando no sea una tecla de
función especial, ya que en este primer ejemplo no hemos contemplado el uso de las
mismas.
Si queremos obtener el valor correspondiente a las teclas de funciones especiales de la
figura 6.16, tendremos que reconsiderar el estado de la variable “función” cuando definimos
el condicional que nos permitirá saber si una de estas teclas ha sido presionada para
capturar el valor correspondiente. Esto significa que en el condicional “If”, la variable
“función” deberá ser igual a 1 para determinar que una tecla de “función especial” ha sido
presionada.
Debido a que las teclas de funciones especiales no retornan un valor equivalente a un
símbolo (ASCII), eliminaremos del ejemplo anterior las líneas correspondientes a la
información presentada en la segunda línea de la pantalla LCD.

_______________________________________________________________________________________
181
program PS2_02
main:
Delay_ms(100)
Lcd_Out(1, 1, "Tecla Func.: ") ' Escribimos la palabra "Caracter:" en la primera línea.
While TRUE
' si el campo o variable "funcion" es igual a uno (lo cual significa que una de las
' teclas de función especial ha sido presionada) y...
End If
Wend
End.

_______________________________________________________________________________________
182
De este ejemplo podremos ver en la pantalla LCD solamente los valores correspondientes a
las teclas de funciones especiales, especificados en la tabla de la figura 6.16.
Esto significa que si presionamos la tecla “ESC”, deberíamos poder ver su valor
correspondiente “34” en la pantalla LCD como se muestra a continuación:
Figura 6.23
Si presionamos la tecla “Print Screen”, el valor correspondiente según la tabla de la figura
6.16 cargado en la variable “valor” sería:
Figura 6.24
Veamos el siguiente ejemplo en el cual mostraremos el símbolo ASCII correspondiente a
una tecla en la primera línea de la pantalla LCD, y el valor correspondiente a las teclas de
funciones especiales en la segunda línea de la pantalla.

_______________________________________________________________________________________
183
program PS2_03
main:
Delay_ms(100) ' Retardo de 100 milisegundos.
Lcd_Out(1, 1, "ASCII: ") ' Escribimos la palabra "Caracter:" en la primera línea.
Lcd_Out(2, 1, "Tecla Func.: ") ' Escribimos la palabra "ASCII:" en la segunda línea
While TRUE
' si el campo o variable "funcion" es igual a cero (lo cual significa que ninguna
' tecla de función especial ha sido presionada) y...
Lcd_Chr(1, 8, Valor) ' Mostramos el equivalente ASCII en la posición
' especificada, línea 2, columna 12.
Else

_______________________________________________________________________________________
184
End If
End If
Wend
End.

_______________________________________________________________________________________
185
Capítulo VII. Memoria de Datos EEPROM
7.1.- La Memoria de Datos EEPROM.
La memoria EEPROM de datos resulta muy importante cuando necesitamos almacenar
información que no queremos que se pierda al desconectar la energía de nuestros
proyectos. La capacidad de esta memoria varía según el modelo de microcontrolador que
escojamos, y no todos cuentan con esta característica. Sin embargo los microcontroladores
que hemos estado utilizando en esta edición cuentan con este hardware en su arquitectura
interna.
Por ejemplo, un PIC16F877 cuenta con una memoria de datos de 256 bytes al igual que la
serie de la familia PIC18FXX2 y la serie de la familia PIC18FXX8. Esta es una información
puede ser verificada directamente en la hoja de características técnicas de cada
microcontrolador. Sin embargo, haremos un mapa de memoria de datos para el
microcontrolador PIC16F877, a través del cual explicaremos la forma de almacenar
información en posiciones predeterminadas en la programación de cada ejemplo propuesto.
Mapa de memoria de un microcontrolador PIC16F877:
0000: 00 01 02 03 04 05 06 07
0008: 08 09 0A 0B 0C 0D 0E 0F
0010: 10 11 12 13 14 15 16 17
0018: 18 19 1A 1B 1C 1D 1E 1F
0020: 20 21 22 23 24 25 26 27
0028: 28 29 2A 2B 2C 2D 2E 2F
0030: 30 21 32 33 34 35 36 37
0038: 38 39 3A 3B 3C 3D 3E 3F
0040: 40 41 42 43 44 45 46 47
0048: 48 49 4A 4B 4C 4D 4E 4F
0050: 50 51 52 53 54 55 56 57
0058: 58 59 5A 5B 5C 5D 5E 5F
0060: 60 61 62 63 64 65 66 67
0068: 68 69 6A 6B 6C 6D 6E 6F
0070: 70 71 72 73 74 75 76 77
0078: 78 79 7A 7B 7C 7D 7E 7F
0080: 80 81 82 83 84 85 86 87
0088: 88 89 8A 8B 8C 8D 8E 8F
0090: 90 91 92 93 94 95 96 97
0098: 98 99 9A 9B 9C 9D 9E 9F
00A0: A0 A1 A2 A3 A4 A5 A6 A7
00A8: A8 A9 AA AB AC AD AE AF
00B0: B0 B1 B2 B3 B4 B5 B6 B7
00B8: B8 B9 BA BB BC BD BE BF
00C0: C0 C1 C2 C3 C4 C5 C6 C7
00C8: C8 C9 CA CB CC CD CE CF
00D0: D0 D1 D2 D3 D4 D5 D6 D7
00D8: D8 D9 DA DB DC DD DE DF
00E0: E0 E1 E2 E3 E4 E5 E6 E7
00E8: E8 E9 EA EB EC ED EE EF
00F0: F0 F1 F2 F3 F4 F5 F6 F7
00F8: F8 F9 FA FB FC FD FE FF
Memoria de Datos PIC16F877
Figura 7.1

_______________________________________________________________________________________
186
7.2.- Librería EEPROM.
Guardar y leer datos resulta muy sencillo al trabajar en mikroBasic. Este compilador cuenta
con una librería para el control de la memoria EEPROM, la cual tiene una rutina para la
lectura de datos y otra para la escritura de datos en posiciones específicas dentro del mapa
de memoria.
Veamos a continuación la sintaxis de estas dos rutinas.
Lectura de la memoria EEPROM de datos:
7.2.1.- EEPROM_Read(Dirección).
El campo “Dirección” se refiere a la posición dentro del mapa de memoria que deseamos
leer.
Ejemplo:
Dato = EEPROM_Read(0x01) ' Lectura de la memoria EEPROM de datos en la
' dirección 0x01 del mapa de memoria.
Escritura de la memoria EEPROM de datos:
7.2.2.- EEPROM_Write(Dirección, Dato).
El campo “Dirección” se refiere a la posición dentro del mapa de memoria que deseamos
escribir o re-escribir.
El campo “Dato” se refiere a la información que deseamos almacenar, la cual podrá estar
cargada en una variable tipo Byte previamente definida.
Ejemplo:
EEPROM_Write(0x01,Dato) ' Escribe el contenido de la variable “Dato” en la
' dirección 0x01.
La idea principal en cada proyecto será familiarizarse con el uso de la memoria de datos,
almacenando en ella información que deberá poder ser consultada aunque el circuito sea
reiniciado o apagado.
Como se puede observar en la figura 7.2, se requiere el uso de un teclado matricial 4x4
para el ingreso de datos y una pantalla LCD, con la cual se podrá visualizar toda la
información a ser consultada.

_______________________________________________________________________________________
187
Figura 7.2
En este ejercicio vamos a almacenar datos en la memoria EEPROM, para luego ser
consultados y verificados.
Vamos a desarrollar a continuación un sistema de control de acceso, en el cual el usuario
deberá introducir una contraseña previamente almacenada en la memoria de datos. Si la
contraseña es correcta, se genera un mensaje de confirmación en la pantalla. Si la
contraseña es incorrecta, se genera un mensaje de error.
Basados en el diagrama esquemático de la figura 7.2, empezamos el programa realizando la
configuración de los pines de control de los dispositivos periféricos conectados al
microcontrolador.
Antes de empezar a programar, es importante tomar en cuenta cuales serán las posiciones
en la memoria de datos para guardar la contraseña.
Para un sistema de control de acceso donde la contraseña será de seis dígitos, y donde
cada dígito deberá ser almacenado en una posición específica, convenientemente podemos
tomar las posiciones en el mapa de la memoria de datos a partir de la dirección “$10” por
ejemplo, hasta la dirección “$15”, como se puede apreciar en la siguiente tabla:

_______________________________________________________________________________________
188
0000: 00 01 02 03 04 05 06 07
0008: 08 09 0A 0B 0C 0D 0E 0F
0010: 10 11 12 13 14 15 16 17
0018: 18 19 1A 1B 1C 1D 1E 1F
0020: 20 21 22 23 24 25 26 27
0028: 28 29 2A 2B 2C 2D 2E 2F
0030: 30 21 32 33 34 35 36 37
0038: 38 39 3A 3B 3C 3D 3E 3F
0040: 40 41 42 43 44 45 46 47
0048: 48 49 4A 4B 4C 4D 4E 4F
0050: 50 51 52 53 54 55 56 57
0058: 58 59 5A 5B 5C 5D 5E 5F
0060: 60 61 62 63 64 65 66 67
0068: 68 69 6A 6B 6C 6D 6E 6F
0070: 70 71 72 73 74 75 76 77
0078: 78 79 7A 7B 7C 7D 7E 7F
0080: 80 81 82 83 84 85 86 87
0088: 88 89 8A 8B 8C 8D 8E 8F
0090: 90 91 92 93 94 95 96 97
0098: 98 99 9A 9B 9C 9D 9E 9F
00A0: A0 A1 A2 A3 A4 A5 A6 A7
00A8: A8 A9 AA AB AC AD AE AF
00B0: B0 B1 B2 B3 B4 B5 B6 B7
00B8: B8 B9 BA BB BC BD BE BF
00C0: C0 C1 C2 C3 C4 C5 C6 C7
00C8: C8 C9 CA CB CC CD CE CF
00D0: D0 D1 D2 D3 D4 D5 D6 D7
00D8: D8 D9 DA DB DC DD DE DF
00E0: E0 E1 E2 E3 E4 E5 E6 E7
00E8: E8 E9 EA EB EC ED EE EF
00F0: F0 F1 F2 F3 F4 F5 F6 F7
00F8: F8 F9 FA FB FC FD FE FF
Memoria de Datos PIC16F877
Tabla 7.3
7.2.2.1.- Ejemplo de programación #41.
Ahora analice detenidamente el siguiente programa tomando en cuenta cada comentario.
Notará que la clave que hemos establecido en el programa es una serie de dígitos
consecutivos “123456””.
program EEPROM_1

_______________________________________________________________________________________
189
Dim Clave As Byte[7] ' Arreglo para almacenar temporalmente la Clave.
Digito As Byte[7] ' Arreglo para comparar la Clave con los digitos pulsados.
Contador As Byte ' Variable para acumulador temporal.
Sound_Init(PORTE, 0) ' Asignamos el pin RE0 para generar los tonos de confirmación
' cuando se introduce un dígito en el teclado.
inicio:
' Almacenamos los digitos de la contraseña en la memoria EEPROM, en las
' posiciones asignadas por el diseñador del programa.
' La contraseña inicial será: 123456
EEPROM_Write(10, 1) ' 1er digito de la contraseña en la dirección 10 del mapa.
EEPROM_Write(11, 2) ' 2do digito de la contraseña en la dirección 11 del mapa.
EEPROM_Write(13, 5) ' 4to digito de la contraseña en la dirección 13 del mapa.
Lcd_Out(1, 1, "Control - Acceso") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "** Bienvenido **") ' Escribimos un mensaje en la línea 2.
Delay_Ms(2000) ' Pausa de 2 segundoa para poder visualizar en mensaje en la
' pantalla LCD.
Clave:
Clave[1] = EEPROM_Read(10) ' Leemos el 1er Digito de la Clave almacenada.
Clave[2] = EEPROM_Read(11) ' Leemos el 2do Digito de la Clave almacenada.
Clave[4] = EEPROM_Read(13) ' Leemos el 4to Digito de la Clave almacenada.
Lcd_Out(1, 1, "Introduzca su ") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "Clave de Acceso:") ' Escribimos un mensaje en la línea 2.
' pantalla LCD.
Contador = 0 ' Inicializamos la variable del Contador temporal.
espera:
GoSub Teclado ' Verificamos si una tecla ha sido presionada.
If pulsador = 0 Then ' Si no se presionó ninguna tecla, la variable "Pulsador"
GoTo espera ' permanece en cero, y ocurre un salto a "espera".
End If
Sound_Play(880, 80) ' Genera un sonido para anunciar la tecla presionada.
Contador = Contador + 1 ' Aumentamos en una unidad el Contador. De esta manera
' es posible llevar la cuenta de la cantidad de dígitos
' que necesitamos introducir desde el Teclado.

_______________________________________________________________________________________
190
Digito[Contador] = pulsador ' El valor cargado desde el teclado es almacenado
' en la variable de indice igual a "Contador", para
' luego ser comparada con el digito correspondiente
' a la clave almacenada en la EEPROM.
If Contador = 6 Then ' Si Contador = 6, entonces el último digito de la
GoTo Comprobar ' clave fué introducido desde el teclado.
End If
GoTo espera ' Salta a la etiqueta "espera" si la clave no ha
' sido completada.
Comprobar:
' Si DIGITO[X] es igual a CLV[X] el digito es correcto,
' y salta a la etiqueta "paseX",
' si es diferente salta a la subrutina "error"; veamos…
If Digito[1] = Clave[1] Then ' Comparamos el 1er digito de la clave.
GoTo pase1 ' Si es correcto, pasa a comparar el siguiente.
Else ' de lo contrario...
GoTo ErrorClave ' salta al mensaje de error de clave.
End If
pase1:
If Digito[2] = Clave[2] Then ' Comparamos el 2do digito de la clave.
End If
pase2:
End If
pase3:
If Digito[4] = Clave[4] Then ' Comparamos el 4to digito de la clave.
End If
pase4:
End If
pase5:
GoTo ClaveCorrecta ' Si es correcto, salta al mensaje de clave correcta.
End If
' Si los seis dígitos han sido correctos
' se ejecuta la subrutina correspondiente.
ErrorClave:
Lcd_Out(1, 1, "Error de Acceso!") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "****************") ' Escribimos un mensaje en la línea 2.
Delay_ms(2000) ' Pausa de 2 segundoa para poder visualizar

_______________________________________________________________________________________
191
' en mensaje en la pantalla LCD.
GoTo Clave ' Saltamos a la etiqueta "inicio".
ClaveCorrecta:
Lcd_Out(1, 1, " Clave Correcta ") ' Escribimos un mensaje en la línea 1.
' en mensaje en la pantalla LCD
Final:
GoTo Final ' Lazo infinito.
Teclado:
' rutina "teclado".
End.
Para verificar el funcionamiento de este ejercicio, es muy importante recordar que un teclado
de 4 filas por 4 columnas nos devuelve valores consecutivos partiendo de la primera tecla,
entre 1 y 16. Esto significa que los valores impresos en cada tecla no van a coincidir con los
valores entregados por la rutina del teclado matricial.
Tecla Presionada Valor cargado en la variable
1 1
2 2
3 3
A 4
4 5
5 6
6 7
B 8
7 9
8 10
9 11
C 12
* 13
0 14
# 15
D 16
Figura 7.4
Entonces, si la clave del sistema que hemos elegido como ejemplo es 123456, observando
la figura 7.4 nos daremos cuenta que las teclas que debemos presionar consecutivamente
serán: 1, 2, 3, A, 4 y 5.

_______________________________________________________________________________________
192
Para lograr que la clave a introducir desde el teclado sea la que hemos propuesto, entonces
los valores a cargar en la memoria EEPROM de datos deberán ser: 1, 2, 3, 5, 6 y 7. Esta es
una forma de relacionar los dígitos impresos en las teclas y los dígitos reales de la clave
elegida.
7.2.2.2.- Ejemplo de programación #42.
Veamos ahora algunas modificaciones importantes en el ejemplo anterior, en el cual se ha
creado la posibilidad de cambiar la “clave de fábrica” del sistema por una clave
personalizada de seis dígitos, la cual deberá quedar almacenada en las mismas posiciones
de la memoria EEPROM de datos.
Para lograr este objetivo, debemos tomar en cuenta lo siguiente:
En el programa anterior, la clave de fábrica es almacenada en sus respectivas
posiciones cada vez que el microcontrolador es reiniciado. En este nuevo ejemplo,
esta situación deberá ser controlada, debido a que si realizamos un cambio de clave
en el sistema, y éste es reiniciado, lo correcto sería mantener la nueva clave y no la
de fábrica. Para evitar que la nueva clave sea re-escrita por la clave de fábrica,
tomaremos la posición cero “0” de la memoria EEPROM de datos para crear una
bandera que nos indique si la clave ha sido modificada por primera vez. Entonces, si
iniciamos el sistema y su clave nunca ha sido modificada, el valor en la posición cero
de la memoria EEPROM será siempre igual a $FF. Una vez que decidamos cambiar
la clave en el sistema a través de un nuevo menú de opciones que vamos a crear,
entonces tendremos que modificar esta bandera asignando un valor (por ejemplo “1”)
en la posición cero de la memoria EEPROM de datos.
Una vez introducida la nueva clave, a través de un procedimiento que está
detalladamente explicado en los comentarios del programa, procederemos a
almacenar la clave en las mismas posiciones de la memoria EEPROM de datos en
las cuales se encuentra la “clave de fábrica”.
Cada vez que introducimos un digito para almacenar la nueva clave, se deberá
generar un sonido de confirmación de cada tecla pulsada. El sonido es sumamente
importante en este proyecto, ya que permite al usuario saber que un dígito ha sido
introducido en el sistema.
Por último, para comprobar que la nueva clave efectivamente ha sido almacenada
con éxito, será necesario reiniciar el sistema para que éste solicite el ingreso con
clave nuevamente. También es posible verificar estos cambios en la memoria
EEPROM de datos a través del programador de microcontroladores PIC, tomando
una lectura de la memoria EEPROM como se muestra en la figura 7.5.

_______________________________________________________________________________________
193
Figura 7.5
En la figura 7.5 se muestra el contenido de la memoria EEPROM de datos del
microcontrolador. Observe que los valores de la clave de fábrica (123456, 123567 en
relación a los valores entregados por la rutina del teclado) se encuentran en las posiciones
10, 11, 12, 13, 14 y 15. Observe además que el valor en la posición 0 de la memoria es $FF.
Cuando hacemos el primer cambio de clave, por ejemplo, 456789, cuyos valores
relacionados a la rutina del teclado serán 5, 6, 7, 9, 10 (“A” en Hexadecimal) y 11 (“B” en
Hexadecimal), este mapa se verá de la siguiente manera:
Figura 7.6
Observe además que la bandera en la posición cero la ha sido cambiada con un nuevo
valor, “1” en nuestro ejemplo.

_______________________________________________________________________________________
194
Analice detenidamente el siguiente programa, siga paso a paso los comentarios y saltos de
línea para una mejor comprensión:
program Control_Acceso
Dim Clave As Byte[7] ' Arreglo para almacenar temporalmente la Clave.
Digito As Byte[7] ' Arreglo para comparar la Clave con los digitos pulsados.
Contador As Byte ' Variable para acumulador temporal.
ClavedeFabrica As Byte ' Bandera para determinar si la Clave ha sido modificada.
Sound_Init(PORTE, 0) ' Asignamos el pin RE0 para generar los tonos.
inicio:
' Es importante verificar si la "Clave de fábrica" ha sido cambiada, ya que sino
' realizamos esta comprobación, la clave de fábrica será re-escrita cada vez que
' reiniciemos el sistema. Para esto, crearemos una bandera en la posición 0 de
' la memoria de datos. Entonces, si el sistema es iniciado por primera vez, esta
' posición será igual a $FF (Cuando tenemos un microcontrolador nuevo, y no hemos
' almacenado datos en su EEPROM, esta contiene en cada una de sus posiciones este
' valor, $FF).
' Al leer la posición “0” y compararla con un valor que va a definir que la clave ha
' sido cambiada, entonces sabremos si debemos saltar la rutina que almacena la
' clave de fábrica cada vez que se reinicia el microcontrolador.
' El valor para definir que la clave fue cambiada será “1”. Mas adelante, en la
' rutina respectiva al cambio de clave, este valor se almacenará en la posición
' “0” de la EEPROM de datos.
ClavedeFabrica = EEPROM_Read(0) ' Carga el valor almacenado en la posición 0
' de la EEPROM en la variable.
If ClavedeFabrica = 1 Then ' Si el valor es igual a 1, la Clave fue cambiada,
GoTo Bienvenido ' y se salta la grabación de la clave de fábrica.
End If

_______________________________________________________________________________________
195
' Si la bandera o valor de la posición 0 de la EEPROM no ha sido modificada,
' almacenamos los digitos de la contraseña en la memoria EEPROM, en las
' posiciones asignadas por el diseñador del programa.
' La contraseña o clave de fábrica será: 123456
EEPROM_Write(11, 2) ' 2do digito de la contraseña en la dirección 11 del mapa.
Bienvenido:
Lcd_Out(1, 1, "Control - Acceso") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "** Bienvenido **") ' Escribimos un mensaje en la línea 2.
' pantalla LCD.
Clave:
Clave[2] = EEPROM_Read(11) ' Leemos el 2do Digito de la Clave almacenada.
Lcd_Out(1, 1, "Introduzca su ") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "Clave de Acceso:") ' Escribimos un mensaje en la línea 2.
' pantalla LCD.
espera:
GoTo espera ' permanece en cero, y ocurre un salto a "espera".
End If
GoTo Comprobar ' clave fué introducido desde el teclado.
End If
GoTo espera ' Salta a la etiqueta "espera" si la clave no ha
' sido completada.
Comprobar:
' Si DIGITO[X] es igual a CLV[X] el digito es correcto,
' y salta a la etiqueta "paseX",
' si es diferente salta a la subrutina "error"; veamos…

_______________________________________________________________________________________
196
End If
pase1:
If Digito[2] = Clave[2] Then ' Comparamos el 2do digito de la clave.
End If
pase2:
End If
pase3:
End If
pase4:
End If
pase5:
GoTo ClaveCorrecta ' Si es correcto, salta al mensaje de clave correcta.
End If
' Si los seis dígitos han sido correctos
' se ejecuta la subrutina correspondiente.
ErrorClave:
Lcd_Out(1, 1, "Error de Acceso!") ' Escribimos un mensaje en la línea 1.
' en mensaje en la pantalla LCD.
GoTo Clave ' Saltamos a la etiqueta "inicio".
ClaveCorrecta:
Lcd_Out(1, 1, " Clave Correcta ") ' Escribimos un mensaje en la línea 1.
Pulsador = 0 ' Inicializamos la variable "Pulsador"
Menu:
Lcd_Out(1, 1, "Cambio de Clave ") ' Escribimos un mensaje en la línea 1.

_______________________________________________________________________________________
197
Opcion_1:
Lcd_Out(1, 1, "Presione C para") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, "cambiar la clave") ' Escribimos un mensaje en la línea 2.
GoSub Teclado ' Verificamos si ha sido presionada una tecla.
If Pulsador = 0 Then ' Si pulsador = 0, significa que ninguna tecla
GoTo Opcion_1 ' ha sido presionada. Entonces salta a “Opcion_1”
End If
If Pulsador = 12 Then ' Si pulsador = 12, entonces hemos presionado la
GoTo CambiodeClave ' tecla "C" en el Teclado matricial.
Else ' De lo contrario...
GoTo Menu ' Salta al menú de inicio.
End If
CambiodeClave:
Lcd_Out(1, 1, " Introduzca la ") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, " clave nueva ") ' Escribimos un mensaje en la línea 2.
espera_2:
GoTo espera_2 ' permanece en cero, y ocurre un salto a "espera_2".
End If
GoTo GrabarClave ' clave fué introducido desde el teclado.
End If
GoTo espera_2 ' Salta a la etiqueta "espera" si la clave no ha
' sido completada.
GrabarClave:
delay_ms(1000)
Lcd_Out(1, 1, " Grabando la ") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, " nueva clave ") ' Escribimos un mensaje en la línea 2.
EEPROM_Write(10, Digito[1]) ' 1er digito de la contraseña en la dirección 10 del mapa.
EEPROM_Write(11, Digito[2]) ' 2do digito de la contraseña en la dirección 11 del mapa.
EEPROM_Write(12, Digito[3]) ' 3er digito de la contraseña en la dirección 12 del mapa.
EEPROM_Write(13, Digito[4]) ' 4to digito de la contraseña en la dirección 13 del mapa.
EEPROM_Write(0, 1) ' Ponemos un 1 en la posición elegida para la bandera que
' determina si hemos cambiado la clave de fábrica.
Sound_Play(440, 2000) ' Generamos un sonido de confirmación de 2 segundos.
Lcd_Out(1, 1, " Reinicie el ") ' Escribimos un mensaje en la línea 1.
Lcd_Out(2, 1, " sistema... ") ' Escribimos un mensaje en la línea 2.

_______________________________________________________________________________________
198
Fin: GoTo Fin ' Lazo infinito.
Teclado:
' rutina "teclado".
End.
El resultado en este ejemplo es el siguiente:
Al iniciar el programa, veremos una pantalla de bienvenida durante dos segundos y luego la
pantalla que nos indica cuando podremos ingresar la clave.
Figura 7.7
Figura 7.8

_______________________________________________________________________________________
199
Si al ingresar la clave cometemos un error, el mensaje será el siguiente:
Figura 7.9
Si la clave es la correcta, entonces el mensaje será el siguiente:
Figura 7.10
Transcurridos 2 segundos después del mensaje de confirmación de la clave correcta,
veremos el siguiente mensaje que nos indica que debemos cambiar la clave:
Figura 7.11

_______________________________________________________________________________________
200
Para esto debemos presionar la tecla “C” en el teclado matricial del circuito. Este mensaje se
quedará en la pantalla hasta que se introduzca esta orden.
Figura 7.12
Seguidamente será necesario ingresar los nuevos dígitos de la clave, recordando que cada
vez que presionamos una tecla debemos esperar el tono de confirmación del sistema:
Figura 7.13
Al terminar de ingresar la clave, podremos ver un mensaje indicando que la misma esta
siendo almacenada en la memoria EEPROM de datos del microcontrolador. También
escucharemos un sonido de dos segundos de duración. Recuerde que el propósito de este
tiempo es dejar al usuario la oportunidad de poder leer el contenido del mensaje publicado
en la pantalla.

_______________________________________________________________________________________
201
Figura 7.14
Por último, el sistema muestra un mensaje que indica que el sistema deberá ser reiniciado
para poder verificar la nueva clave.
Figura 7.15
En este punto, el programa ha entrado en un lazo infinito.

_______________________________________________________________________________________
202
Capítulo VIII. Conversor A/D.
8.1.- El conversor A/D.
Los microcontroladores de las familias PIC16F87x y PIC18Fxxx de los cuales estaremos
hablando a continuación, poseen un convertidor Analógico-Digital que convierte una señal
analógica en un número de 8 o 10 bits, según sea la configuración elegida por el diseñador.
En los microcontroladores PIC de 28 pines como el PIC16F870, encontraremos que solo
poseen 5 entradas para la conversión A/D, y en el caso particular de los microcontroladores
de 40 pines como el PIC16F877 o el PIC18F442 por ejemplo, se puede observar que
poseen 8 canales para conversión A/D, identificadas por las siglas AN(n), las cuales se
encuentran distribuidas entre el puerto A y el puerto E, como se muestra en el diagrama de
pines de la figura 8.1:
Figura 8.1
En el microcontrolador PIC16F877, cada canal de conversión A/D está conectado a un pin
ubicado en el puerto “A” y en el puerto “E”. Por ejemplo, el canal AN0 corresponde al pin # 2
del microcontrolador, o expresado de otra manera, al pin RA0 del puerto A. El canal AN1
corresponde al pin # 3; el canal AN2 corresponde al pin # 4 y así sucesivamente; entonces
se puede ver claramente que el puerto A cuenta con cinco de los ocho canales del conversor
A/D, y los otros tres canales están ubicados en los pines correspondientes al puerto E del
microcontrolador.

_______________________________________________________________________________________
203
El conversor A/D de estos microcontroladores es de 10 bits, lo cual significa que tenemos
210
= 1024 datos de conversión, como se puede observar en la tabla de la figura 8.2.
Decimal BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0 BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0
0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 1
2 0 0 0 0 0 0 0 0 1 0
3 0 0 0 0 0 0 0 0 1 1
4 0 0 0 0 0 0 0 1 0 0
1018 1 1 1 1 1 1 1 0 1 0
1019 1 1 1 1 1 1 1 0 1 1
1020 1 1 1 1 1 1 1 1 0 0
1021 1 1 1 1 1 1 1 1 0 1
1022 1 1 1 1 1 1 1 1 1 0
1023 1 1 1 1 1 1 1 1 1 1
REGISTRO BAJO (ADRESL)
REGISTRO ALTO (ADRESH)
Figura 8.2
Para comprender aún mejor este punto, veamos el siguiente ejemplo:
Si se configura el conversor A/D a 8 bits e introducimos una señal cuya amplitud varía entre
0 y 5 voltios, y donde el voltaje de referencia del conversor es 5 voltios, entonces la
resolución que obtendremos en la conversión sería la siguiente:
Resolución = n
Vi
2
max
Resolución = 8
2
5V
Resolución =
256
5V
Resolución = 0.0196 0.02 V
Esto significa que la resolución a 8 bits para el ejemplo planteado es de 20 mV por cada
paso que da el conversor A/D entre 0 y 255.

_______________________________________________________________________________________
204
Si configuramos el conversor A/D a 10 bits, entonces tenemos que 210
= 1024, y por lo tanto
obtenemos una resolución mayor, lo cual podemos demostrar realizando los cálculos
correspondientes:
Resolución = n
Vi
2
max
Resolución = 10
2
5V
Resolución =
1024
5V
Resolución = 0.00488 0.0049 V
Entonces la resolución a 10 Bits es de 4.9 mV por cada paso que da el conversor A/D entre
0 y 1023.
Veamos el diagrama de bloques del conversor A/D (figura 8.3):
Figura 8.3

_______________________________________________________________________________________
205
Resulta interesante saber que se puede obtener más resolución en términos de voltios por
paso, si utilizamos un voltaje de referencia menor al de la alimentación del microcontrolador
a través de los pines “Ref+” o “Ref-“ según sea el caso.
Por ejemplo, si aplicamos un voltaje de referencia positivo igual a 2.5 voltios en el pin
RA3/AN3/Ref+ del puerto A, el cual ha sido previamente configurado para esto, entonces:
Resolución = n
Vi
2
max
Resolución = 10
2
5
.
2 V
Resolución =
1024
5
.
2 V
Resolución = 0.00244 0.0025 V
La resolución del conversor A/D sería de 2.5 mV por cada paso entre 0 y 1023. Hay una
serie de pasos que debemos tomar en cuenta para llevar a cabo una conversión A/D,
basados en el diagrama de bloques de la figura 8.3:
Lo primero, será configurar los canales de entrada que utilizaremos para introducir la señal
analógica al conversor A/D y los canales para voltajes de referencia, en el caso de ser
necesario. Esto se hace seleccionando la combinación correspondiente en los bits PCFG3,
PCFG2 PCFG1 y PCFG0 del registro de control ADCON1 (figura 8.4).
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
ADFM ------ ------ ------ PCFG3 PCFG2 PCFG1 PCFG0
Figura 8.4

_______________________________________________________________________________________
206
En este punto es muy conveniente detenerse a analizar la tabla de la figura 8.5, que define
cuales pines del puerto A y E serán entradas al conversor A/D, según la combinación
elegida.
PCFG3 PCFG2 PCFG1 PCFG0 AN7 AN6 AN5 AN4 AN3 AN2 AN1 AN0 Vref+ Vref-
0 0 0 0 A A A A A A A A Vdd Vss
0 0 0 1 A A A A Vref+ A A A RA3 Vss
0 0 1 0 D D D A A A A A Vdd Vss
0 0 1 1 D D D A Vref+ A A A RA3 Vss
0 1 0 0 D D D D A D A A Vdd Vss
0 1 0 1 D D D D Vref+ D A A RA3 Vss
0 1 1 x D D D D D D D D Vdd Vss
1 0 0 0 A A A A Vref+ Vref- A A RA3 RA2
1 0 0 1 D D A A A A A A Vdd Vss
1 0 1 0 D D A A Vref+ A A A RA3 Vss
1 0 1 1 D D A A Vref+ Vref- A A RA3 RA2
1 1 0 0 D D D A Vref+ Vref- A A RA3 RA2
1 1 0 1 D D D D Vref+ Vref- A A RA3 RA2
1 1 1 0 D D D D D D D A Vdd Vss
1 1 1 1 D D D D Vref+ Vref- D A RA3 RA2
Figura 8.5
El segundo paso será activar el canal en el cual se encuentra presente la señal analógica
para que pase a la etapa de muestreo. La selección de las entradas analógicas se realiza
configurando los bits CHS2 (bit 5), CHS1 (bit 4) y CHS0 (bit 3) del registro ADCON0 (figura
8.6):
ADCS1 ADCS0 CHS2 CHS1 CHS0 GO/DONE ------ ADON
Figura 8.6
CHS2 CHS1 CHS0 Canal/Pin
0 0 0 = Canal 0 (AN0)/RA0
0 0 1 = Canal 1 (AN1)/RA1
0 1 0 = Canal 2 (AN2)/RA2
0 1 1 = Canal 3 (AN3)/RA3
1 0 0 = Canal 4 (AN4)/RA5
1 0 1 = Canal 5 (AN5)/RE0
1 1 0 = Canal 6 (AN6)/RE1
1 1 1 = Canal 7 (AN7)/RE2
Figura 8.7
En mikroBasic, la conversión de datos A/D es posible gracias a su librería “ADC”, la cual
podemos ubicar fácilmente en la pestaña de librerías, y la cual cuenta con tan solo una
rutina, capaz de hacer todo el trabajo fácilmente y sin complicaciones.

_______________________________________________________________________________________
207
Debemos saber que es posible seleccionar el canal que deseamos utilizar, con la rutina
correspondiente en la librería, Adc_Read(canal), en la cual sólo se especifica cual será el
canal de entrada de la señal a ser convertida. El resultado de la lectura del canal
especificado podrá ser almacenado en una variable previamente declarada, tal y como se
muestra en el siguiente ejemplo:
Dim humedad As Word
humedad = Adc_Read(2)
Significa que el resultado de la conversión de una señal presente en la entrada “AN0” será
almacenado en la variable “humedad”, la cual ha sido previamente definida en el programa,
tipo Word, debido a que el conversor está configurado a 10 bits.
Aunque la rutina Adc_Read(canal) se encarga de controlar el registro ADCON0 ahorrando
algunas líneas de programa, consideramos conveniente hacer una revisión de los registros
de control del conversor A/D.
ADCS1 ADCS0 CHS2 CHS1 CHS0 GO/DONE ------ ADON
Figura 8.8
Bit 7 y Bit 6: Selección del reloj del conversor A/D.
ADCS1 ADCS0
0 0 = Fosc/2
0 1 = Fosc/8
1 0 = Fosc/32
1 1 = FRC
Conversión del Reloj
Figura 8.9
Bit 5, Bit 4 y Bit 3: Selección del canal de entrada.
CHS2 CHS1 CHS0 Canal/Pin
0 0 0 = Canal 0 (AN0)/RA0
0 0 1 = Canal 1 (AN1)/RA1
0 1 0 = Canal 2 (AN2)/RA2
0 1 1 = Canal 3 (AN3)/RA3
1 0 0 = Canal 4 (AN4)/RA5
1 0 1 = Canal 5 (AN5)/RE0
1 1 0 = Canal 6 (AN6)/RE1
1 1 1 = Canal 7 (AN7)/RE2
Figura 8.10

_______________________________________________________________________________________
208
Bit 2: Estado de la conversión.
GO/DONE: Solo funciona si ADON = 1
1 = Conversión A/D en progreso.
0 = Conversión A/D detenida.
Bit 1: Este bit no está implementado.
Bit 0: Enciende el conversor A/D.
1 = conversor A/D encendido.
0 = conversor A/D apagado.
8.1.2..- El registro ADCON1.
Figura 8.11
Bit 7: Justificación del resultado de la conversión a 10 bits a la derecha o izquierda.
1 = Justifica a la derecha.
0 = Justifica a la Izquierda.
Bit 6 al Bit 4: No están implementados.
Bit3, Bit 2, Bit 1 y Bit 0: Configuración
Figura 8.12

_______________________________________________________________________________________
209
A = Entrada Analógica
D = I/O Digital
Cuando realizamos la conversión A/D a 10 bits, el resultado de la conversión se almacena
en dos registros, ADRESH y ADRESL, los cuales unidos forman un solo registro de 16 bits,
solo que en la parte alta de éste, los 6 bits mas significativos (Bit 2 al Bit 7 de ADRESH,
figura 8.13) no son tomados en cuenta, es decir, son considerados como “0”. Esto da como
resultado que el valor máximo a ser almacenado en él será: 0000001111111111, es decir,
1023.
BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0 BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0
0 0 0 0 0 0
Figura 8.13
En la conversión a 10 bits también es muy importante considerar el bit 7 (ADFM) del registro
de control ADCON1, ya que este bit mantiene el resultado de la conversión de 10 bits
justificado, ya sea a la derecha si ADFM = 1, como lo demuestra la figura 8.14, o a la
izquierda si ADFM = 0 como lo demuestra la figura 8.15:
0 0 0 0 0 0
Figura 8.14
0 0 0 0 0 0
Figura 8.15
Cuando justificamos el resultado de la conversión A/D a la izquierda, el bit menos
significativo de éste es el bit 6 del registro ADRESL, y el bit más significativo es el bit 7 del
registro ADRESH.
Para realizar los siguientes ejemplos de programación, hemos propuesto un circuito inicial
en el cual tendremos conectado al microcontrolador una pantalla Glcd para visualizar los
resultados de la conversión, y un potenciómetro con el cual estaremos variando el nivel de
voltaje entre 0 voltios y 5 voltios en una de las entradas del conversor, específicamente en
RA2.
A medida que vayamos avanzando, iremos incorporando nuevas características a cada
ejercicio, de tal manera que podamos generar algunas nuevas ideas que sirvan en el
desarrollo de proyectos que requieran de una conversión A/D.

_______________________________________________________________________________________
210
El diagrama esquemático de la figura 8.16 muestra el conexionado entre en
microcontrolador y sus periféricos:
Figura 8.16
Recordemos los pasos a seguir cuando de una pantalla Glcd se trata:
1. Ya que vamos a imprimir texto en la pantalla Glcd, lo primero será invocar al archivo
de fuentes creado anteriormente, en el capítulo de Pantallas LCD y GLCD.
2. Realizamos la configuración de pines de control y datos de la pantalla Glcd.
3. Declaramos algunas variables, en las cuales estaremos almacenando los datos
producto de la conversión A/D y el texto a ser mostrado en la pantalla.
4. Configuramos los registros correspondientes al conversor A/D y puertos.

_______________________________________________________________________________________
211
5. Inicializamos la pantalla Glcd e invocamos el módulo de fuentes deseado, pues
recordemos que en un archivo de fuentes, podemos tener más de un módulo.
6. En un lazo infinito, realizamos la conversión A/D y la cargamos en una variable tipo
Word. El valor convertido desde la entrada analógica y almacenado en la variable, lo
convertimos de Word a string para poder visualizarlo correctamente en la pantalla.
7. Finalmente, cargamos el texto y el contenido de la variable tipo string en una posición
predeterminada de la pantalla Glcd.
Veamos a continuación la solución al planteamiento.
program ADC_01
Dim dato As Word ' Variable de 16 bits para cargar el valor de la
' conversión A/D.
Dim DatoStr As string[4] ' Variable para conversión datos.
main:
ADCON1 = 0 ' Configura el puerto A como analógico,
' VDD es el voltaje de referencia --> Vref.
TRISA = $FF ' Configura el puerto A como entrada.
While (TRUE)
dato = Adc_Read(2) ' Carga el resultado de la conversión de
' 10 bits en la variable.
wordtostr(dato, DatoStr) ' Conversión de word a string
texto = "Conversion A/D: " ' Cargamos la variable con un mensaje.
Glcd_Write_Text(texto, 6, 1, 1) ' Escribimos el contenido
Glcd_Write_Text(DatoStr, 92, 1, 1) ' Escribimos el contenido
Wend
End.

_______________________________________________________________________________________
212
El resultado de este programa será la pantalla que vemos en la figura 8.17, en la cual
podremos observar el valor de la variable “dato” convertida en un string de uno a cuatro
dígitos, la cual puede variar su valor entre 0 y 1023 al modificar la posición del
potenciómetro conectado en la entrada del conversor A/D:
!
!
!
!
Figura 8.17

_______________________________________________________________________________________
213
Veamos ahora como podríamos configurar este ejemplo, para hacer uso de un voltaje de
referencia en el conversor A/D, de tal manera que podamos variar la resolución de la
conversión de datos.
Para esto, será necesario tomar en cuenta nuevamente el registro ADCON1 y la tabla de
configuración de pines del conversor:
Figura 8.18
Recordemos entonces que para configurar los pines de entrada del conversor, debemos
hacer uso de los bits 0 al 3 del registro ADCON1, basados en la siguiente tabla de
configuración de pines del mismo.
En este ejemplo, elegiremos como pin de voltaje de referencia positivo a RA3 y
mantendremos RA2 como pin de entrada analógica. Esto significa que una de las
configuraciones posibles representadas en la tabla, puede ser la que encontramos en la
línea 2 de la misma, como se muestra a continuación:
Figura 8.19
La configuración de los bits en el registro ADCON1 entonces deberá ser igual a:
ADCON1 = %00000001 (en binario)
o visto de otra manera:
ADCON1 = 1 (en decimal)

_______________________________________________________________________________________
214
Pero antes de continuar con el ejercicio, veamos como debería quedar el circuito propuesto:
Figura 8.20
Observe que hemos puesto un potenciómetro de 5 kohm adicional con respecto al circuito
anterior y conectado al pin RA3, de tal manera que podamos variar el voltaje de referencia
aplicado al mismo.
En base a lo estudiado anteriormente, podríamos deducir que para este nuevo circuito, si
giramos el potenciómetro REF hasta obtener un voltaje de referencia de 5 Voltios, al variar la
entrada en RA2 el resultado en la pantalla debería ser el mismo en comparación con el
ejemplo anterior, es decir, al variar el recorrido del potenciómetro POT de extremo a
extremo, la lectura debe variar entre 0 y 1023.

_______________________________________________________________________________________
215
El cálculo de la resolución se vería así:
Resolución = n
Vi
2
max
Resolución = 10
2
5V
Resolución =
1024
5V
Resolución = 0.00488 0.0049 V
Resolución = 4.9 mV
¿Pero que sucede si ponemos un voltaje de referencia igual a 2.5 voltios? Fácilmente
podremos ver el resultado variando el potenciómetro REF hasta obtener el voltaje de
referencia deseado.
Con un voltaje de referencia igual a la mitad del voltaje que aplicamos en RA2, la resolución
en la conversión sería:
Resolución = n
Vi
2
max
Resolución = 10
2
5
.
2 V
Resolución =
1024
5
.
2 V
Resolución = 0.00244 0.0025 V
En este caso se podrá observar que la conversión entre 0 y 5 voltios en el pin RA2 se hará
en la mitad del recorrido del potenciómetro POT.

_______________________________________________________________________________________
216
Para esto, el único cambio necesario en el programa será con respecto a la configuración
del registro ADCON1:
program ADC_02
' conversión A/D.
main:
' RA3 es el voltaje de referencia --> Vref.
While (TRUE)
Wend
End.
En vista de que hemos estado convirtiendo el nivel de un voltaje que varía entre 0 y 5 voltios
en datos de de 10 bits a través del conversor A/D, sería interesante agregar mas información
en la pantalla Glcd en base a éstos, como por ejemplo, el valor del voltaje en la entrada
analógica.
Esto también significa que basados en los datos obtenidos en la conversión A/D los cuales
varían entre 0 y 1023, el voltaje de referencia seleccionado a través del potenciómetro POT

_______________________________________________________________________________________
217
en RA3 y el valor de la resolución calculada, podemos saber cual es el voltaje aplicado en la
entrada RA2, para luego presentar el mismo en la pantalla Glcd.
Esto es posible gracias a un sencillo cálculo, como lo demostraremos a continuación:
1. Sabemos que la conversión genera datos entre 0 y 1023 los cuales son almacenados
temporalmente en una variable que hemos llamado “dato”.
2. sabemos además el valor calculado de la resolución para un voltaje de referencia
igual al voltaje aplicado en RA3.
Por ejemplo, si tenemos un valor de conversión igual a 512, y el voltaje de referencia del
conversor es de 5 voltios, entonces:
Voltaje = (Resolución x Valor de la conversión A/D)
Voltaje en RA2 = (4.9 mV x 512)
Voltaje = 2,5088 voltios
Esto significa que el voltaje en la entrada RA2 cuando la conversión nos ha entregado un
valor igual a 512, debería ser igual o aproximadamente el voltaje calculado.
Convirtamos esta formula en código y observemos el resultado:
program ADC_03
Dim Voltaje As Float ' Variable para almacenar el valor a calcular, el
' cual deberá ser tipo Float.
VoltajeStr As string[8] ' Variable para presentar la información en la Glcd
datoflt As Float ' Esta variable se ha decladaro para cargar el valor
' de la conversión en formato de punto flotante,

_______________________________________________________________________________________
218
' debido a que haremos cálculos de punto flotante a
' través de la formula planteada en la explicación.
' conversión A/D.
main:
While (TRUE)
datoflt = dato
Voltaje = datoflt * 0.0049 ' Calculamos el valor del voltaje, sabiendo que
' la resolución es igual a 0.0049 voltios.
FloatToStr(Voltaje, VoltajeStr) ' Convertimos el valor de Float a String
texto = "Volt. RA2: " ' Cargamos la variable con un mensaje.
Glcd_Write_Text(texto, 6, 2, 1) ' Escribimos el contenido en la línea 2
Glcd_Write_Text(VoltajeStr, 72, 2, 1) ' Escribimos el contenido de la variable
Wend
End.
Se observa en el programa que hemos agregado tres nuevas variables. Considerando que
realizaremos cálculos cuyos resultados generan decimales, dos de estas variables han sido
declaradas como “float” o punto flotante.
En una de estas variables, “Voltaje”, almacenaremos el resultado en el cálculo del valor del
voltaje en RA2, por lo cual esta variable deberá ser tipo “float”.
La otra variable tipo “float” se denominó “datoflt”, y en ella cargaremos el valor de la
conversión proveniente de la variable “dato” la cual ha sido ya declarada anteriormente
como “word”.
En la tercera nueva variable, almacenaremos la conversión de la variable “Voltaje” de “float”
a “string”, para poder visualizar el dato en la pantalla Glcd.
Por último, se han agregado las líneas de programa correspondientes al cálculo de la
formula, conversión de datos e impresión de datos en la pantalla.

_______________________________________________________________________________________
219
Veamos a continuación algunos de los resultados de la conversión en la pantalla Glcd:
Figura 8.21

_______________________________________________________________________________________
220
Figura 8.22

_______________________________________________________________________________________
221
8.2.- El Acelerómetro.
En el siguiente ejemplo realizaremos un programa para el control de un acelerómetro triaxial,
el cual posee tres salidas analógicas las cuales deseamos representar en un formato digital
en la pantalla Glcd, y en la cual incluiremos además de los datos de la conversión A/D de
cada salida, los valores de los voltajes calculados en cada una de ellas, en base a algunas
características del dispositivo, las cuales estudiaremos a continuación.
El acelerómetro propuesto es de la empresa Dimension Engineering LLC.
http://www.dimensionengineering.com/DE-ACCM3D2.htm
El modelo elegido ha sido el siguiente:
Buffered 3D Accelerometer, Código: DE-ACCM3D2
Figura 8.23 (Fuente: http://www.dimensionengineering.com/DE-ACCM3D2.htm)
Antes de empezar, veamos resumidamente que es un acelerómetro y que utilidad tendría en
nuestros proyectos electrónicos.
Básicamente, un acelerómetro es un instrumento capaz de medir aceleraciones y fuerzas
inducidas por la gravedad. Es un dispositivo muy utilizado hoy en día en equipos como
cámaras fotográficas, juegos de video, reproductores portátiles entre otros, para detectar el
movimiento o giro del mismo.

_______________________________________________________________________________________
222
En pocas palabras, podríamos medir la dirección hacia la cual se encuentra un objeto con
respecto al espacio tridimensional X, Y, Z.
Veamos a continuación algunas características importantes de este modelo:
El voltaje de operación está entre 3.5V y 15V, debido a que incorpora un regulador de
voltaje de 3.3V.
El circuito cuenta con un punto de conexión (regulator bypass) a través del cual
podemos alimentar el acelerómetro entre 2.4V y 3.6V, y prescindir del regulador de
voltaje.
Si decidimos utilizar el regulador de voltaje, podremos utilizar el punto de conexión
(regulador bypass), para tomar el voltaje de referencia para el conversor A/D, el cual
en este caso será de 3.3V.
El circuito posee protección en su entrada, en caso de una conexión de polaridad
invertida en la entrada al regulador de voltaje.
Mide un rango de ±2g en sus tres ejes X, Y, Z, con una sensibilidad de hasta 720 mV/g.
Según los datos proporcionados por su fabricante, los datos de rangos de sensibilidad para
los siguientes voltajes de operación son los siguientes:
Para un voltaje de operación = 3.6V, la sensibilidad = 760 mV/g.
En nuestro caso, haremos uso del regulador de voltaje de 3.3V, por lo cual los cálculos se
realizarán en base a la sensibilidad correspondiente, S = 666 mV/g. Los voltajes máximos en
cada salida observando la placa del acelerómetro en sus posiciones extremas, considerando
que la alimentación del acelerómetro es de 3.3V son los siguientes:

_______________________________________________________________________________________
223
Figura 8.24 (Fuente: http://www.dimensionengineering.com/DE-ACCM3D2.htm)
Veamos algunos ejemplos proporcionados por el fabricante.
Calculo de la aceleración en base a un voltaje medido en la salida X del acelerómetro.
Datos conocidos:
Voltaje de alimentación = 3.3V
Voltaje en la salida X = 1.95V
A 3.3V, el punto de 0g en el acelerómetro es equivalente a 1.66V en su salida.
Entonces,
1.95V – 1.66V = +0.29V con respecto al punto de 0g del acelerómetro.
Si sabemos que la sensibilidad a 3.3V es 666 mV/g, 0.29V ÷ 0.666 V/g = 0.435 g
Esto da como resultado que la aceleración en el eje X es +0.435 g

_______________________________________________________________________________________
224
Calculemos ahora la inclinación del circuito en el eje Y, con respecto al voltaje en la salida
correspondiente. Para este cálculo utilizaremos un voltaje de ejemplo, igual a 1.85 V.
Datos conocidos:
El voltaje en la salida Y cuando el circuito está orientado en paralelo con respecto al
suelo es igual a 1.66V (ver figura 8.25).
Figura 8.25
El voltaje en la salida Y = 1.85V:
Figura 8.26
Entonces,
1.85V – 1.66V = +0.19V con respecto al punto de 0g.
Con una sensibilidad de 666 mV/g, 0.19 V ÷ 0.666 V/g = 0.2852 g
Arc Sen (0.2852) = 0.289215

_______________________________________________________________________________________
225
Este resultado expresado en radianes pude ser convertido en grados de la siguiente forma:
Angulo = (180 x 0.289215) / 3.14159 = 16.57 º
La inclinación del circuito de la figura 8.26 es igual a 16.5 º con respecto al suelo.
En base a los datos proporcionados anteriormente, realizaremos los siguientes ejercicios de
programación, partiendo del diagrama esquemático propuesto en la figura 8.27.
Figura 8.27
Lo primero que debemos observar en el diagrama esquemático, es que la configuración
entre la pantalla Glcd y el microcontrolador no ha cambiado, por lo cual continuamos con la
misma configuración de pines de control y datos en nuestros programas.
En este caso, podemos ver que las salidas del acelerómetro han sido conectadas en el
puerto A, incluyendo el pin denominado “bypass” o “BP” en el acelerómetro, del cual
tomaremos el voltaje de referencia para el conversor A/D.

_______________________________________________________________________________________
226
program ADC_04
Eje_X As Word ' Variable de 16 bits para cargar el valor de la
' conversión A/D de la salida X del Acelerómetro.
Eje_Y As Word ' Variable de 16 bits para cargar el valor de la
' conversión A/D de la salida Y del Acelerómetro.
Eje_Z As Word ' Variable de 16 bits para cargar el valor de la
' conversión A/D de la salida Z del Acelerómetro.
main:
While (TRUE)
texto = "Acelerometro" ' Cargamos la variable con un titulo.
texto = "Eje Dato" ' Cargamos la variable con un Sub-titulo.
Eje_X = Adc_Read(0) ' Carga el resultado de la conversión de
' de 10 bits en la variable.
wordtostr(Eje_X, DatoStr) ' Conversión de word a string
texto = "X:" ' Cargamos la variable con un mensaje.
Glcd_Write_Text(DatoStr, 16, 4, 1) ' Escribimos el contenido de la conversión
Eje_Y = Adc_Read(1) ' Carga el resultado de la conversión de

_______________________________________________________________________________________
227
wordtostr(Eje_Y, DatoStr) ' Conversión de word a string
texto = "Y:" ' Cargamos la variable con un mensaje.
Glcd_Write_Text(DatoStr, 16, 5, 1) ' Escribimos el contenido de la variable
Eje_Z = Adc_Read(2) ' Carga el resultado de la conversión de
wordtostr(Eje_Z, DatoStr) ' Conversión de word a string
texto = "Z:" ' Cargamos la variable con un mensaje.
Wend
End.
Analizando el programa, nos podremos dar cuenta que hemos agregado tres nuevas
variables para almacenar el resultado de la conversión A/D de cada una de las salidas del
acelerómetro.
Estas tres variables llamadas “Eje_X”, “Eje_Y” y “Eje_Z” han sido declaradas tipo “word”, ya
que la conversión A/D está configurada por defecto a 10 bits, por lo cual una variable de 8
bits (byte), no funcionaría en este caso.
Otra de las cosas importantes a resaltar es que el registro ADCON1 esta configurado para
que los pines del puerto “A” que deseamos utilizar en la conversión, RA0, RA1 y RA2 sean
entradas análogas, y para que el pin RA3 sirva de voltaje de referencia positivo.
También contamos con un título para nuestro proyecto, el cual ha sido ubicado en la primera
línea de la pantalla Glcd, al igual que el título de las dos columnas de datos ubicado en la
segunda línea de la pantalla.
texto = "Eje Dato" ' Cargamos la variable con un Sub-titulo.
Por último, tenemos las rutinas correspondientes a la captura y conversión de datos del
acelerómetro:

_______________________________________________________________________________________
228
wordtostr(Eje_X, DatoStr) ' Conversión de word a string
Glcd_Write_Text(DatoStr, 16, 4, 1) ' Escribimos el contenido de la conversión
wordtostr(Eje_Y, DatoStr) ' Conversión de word a string
wordtostr(Eje_Z, DatoStr) ' Conversión de word a string
Las rutinas para la captura y conversión A/D, son básicamente las mismas. Solo hemos
cambiado las variables en las cuales estamos almacenando el dato correspondiente a cada
salida del acelerómetro, la conversión de datos de “word” a “string” y las posiciones
correspondientes a los mensajes y resultados a ser mostrados en la pantalla Glcd.
El resultado de este programa se deberá ver de esta manera:
Figura 8.28

_______________________________________________________________________________________
229
Como se puede ver en la figura 8.28, nuestro programa ha sido capaz de mostrarnos el valor
de la conversión A/D para cada una de las salidas del acelerómetro. Pero éste sería mas útil
aún si pudiésemos contar con estos valores expresados en términos de voltaje y
aceleración, tal y como lo estudiamos antes de empezar a hacer este ejercicio.
8.2.2.- Cálculo del voltaje de entrada del conversor A/D.
Empecemos calculando el voltaje en cada una de las entradas del conversor A/D. Los datos
que debemos tomar en cuenta para este cálculo serían los siguientes:
Para calcular el voltaje necesitamos saber el valor de la resolución en la conversión A/D:
Resolución = n
Vi
2
max
Resolución = 10
2
3
.
3 V
Resolución =
1024
3
.
3 V
Resolución = 0,003222 V
Las formulas para el cálculo de voltaje en cada entrada serían las siguientes:
Voltaje en RA0 = Valor de la conversión cargado en la variable “Eje_X” x 0.003222 V
Voltaje en RA1 = Valor de la conversión cargado en la variable “Eje_Y” x 0.003222 V
Voltaje en RA2 = Valor de la conversión cargado en la variable “Eje_Z” x 0.003222 V

_______________________________________________________________________________________
230
8.2.3.- Calculo de la aceleración en base al voltaje calculado en cada eje.
Datos conocidos:
Voltajes calculados en cada entrada analógica.
A 3.3V, el punto de 0g en el acelerómetro es equivalente a 1.66V en su salida.
Entonces,
La aceleración para el Eje X:
Voltaje en RA0 – 1.66V = Voltaje con respecto al punto de 0g del acelerómetro.
Si sabemos que la sensibilidad a 3.3V es 666 mV/g:
Voltaje con respecto al punto de 0g del acelerómetro ÷ 0.666 V/g = Aceleración en X.
La aceleración para el Eje Y:
Voltaje con respecto al punto de 0g del acelerómetro ÷ 0.666 V/g = Aceleración en Y.
La aceleración para el Eje Z:
Voltaje con respecto al punto de 0g del acelerómetro ÷ 0.666 V/g = Aceleración en X.

_______________________________________________________________________________________
231
program ADC_05
' Variables para calculos de voltaje y aceleración en cada Eje del
' acelerómetro. Todas las variables son declaradas tipo "Float" ya que
' los cálculos realizados generan decimales en el resultado.
Volt_Eje_X As Float
Volt_Acell_X As Float
Acell_X As Float
Volt_Eje_Y As Float
Volt_Acell_Y As Float
Acell_Y As Float
Volt_Eje_Z As Float
Volt_Acell_Z As Float
Acell_Z As Float
Dato_Temp As Float
Dim DatoStr As string[8] ' Variable para conversión de datos.
main:
Acelerometro:

_______________________________________________________________________________________
232
texto = " Volt. Acell." ' Cargamos la variable con un Sub-titulo.
Glcd_Write_Text(texto, 2, 2, 1) ' Escribimos el contenido en la línea 2.
'*************************************************************************
' Rutina correspondiente al Eje X del Acelerómetro ***********************
' Calculamos el Voltaje en RA0:
Dato_Temp = Eje_X ' Cargamos el valor de la conversion A/D
' en una variable temporal tipo "Float".
Volt_Eje_X = Dato_Temp * 0.003222 ' Calculamos el voltaje en RA0.
FloatToStr(Volt_Eje_X, DatoStr) ' Conversión de float a string
Glcd_Write_Text(DatoStr, 15, 4, 1) ' Escribimos el contenido de la conversión.
' Calculamos la Aceleración:
Volt_Acell_X = Volt_Eje_X - 1.66 ' Voltaje con respecto al punto de 0g
' del acelerómetro.
Acell_X = Volt_Acell_X / 0.666 ' Se calcula la aceleración.
FloatToStr(Acell_X, DatoStr) ' Se convierte el resultado a string.
Glcd_Write_Text(DatoStr, 65, 4, 1) ' Se imprime el dato en pantalla.
'*************************************************************************
' Rutina correspondiente al Eje Y del Acelerómetro ***********************
Dato_Temp = Eje_Y ' Cargamos el valor de la conversion A/D
Volt_Eje_Y = Dato_Temp * 0.003222 ' Calculamos el voltaje en RA1.
FloatToStr(Volt_Eje_Y, DatoStr) ' Conversión de float a string
Glcd_Write_Text(DatoStr, 14, 5, 1) ' Escribimos el contenido de la variable.
Volt_Acell_Y = Volt_Eje_Y - 1.66 ' Voltaje con respecto al punto de 0g
Acell_Y = Volt_Acell_Y / 0.666 ' Se calcula la aceleración.
FloatToStr(Acell_Y, DatoStr) ' Se convierte el resultado a string.
'*************************************************************************
' Rutina correspondiente al Eje Z del Acelerómetro ***********************

_______________________________________________________________________________________
233
Dato_Temp = Eje_Z ' Cargamos el valor de la conversion A/D
Volt_Eje_Z = Dato_Temp * 0.003222 ' Calculamos el voltaje en RA2.
FloatToStr(Volt_Eje_Z, DatoStr) ' Conversión de word a string
Glcd_Write_Text(DatoStr, 14, 6, 1) ' Escribimos el contenido de la variable.
Volt_Acell_Z = Volt_Eje_Z - 1.66 ' Voltaje con respecto al punto de 0g
Acell_Z = Volt_Acell_Z / 0.666 ' Se calcula la aceleración.
FloatToStr(Acell_Z, DatoStr) ' Se convierte el resultado a string.
GoTo Acelerometro
End.
El resultado de este programa se puede observar en la siguiente figura:
Figura 8.29
Obviamente, estos valores estarán variando constantemente mientras estemos moviendo el
acelerómetro en diferentes direcciones sobre cada eje.

_______________________________________________________________________________________
234
8.3.- Termocupla.
A continuación haremos una breve introducción al estudio de un dispositivo que resulta ser
muy utilizado en la industria para el control de niveles de temperaturas de rangos muy
amplios, entre -200ºC y 1700ºC.
La termocupla o termopar es un sensor compuesto por dos diferentes tipos de metales
unidos en una de sus puntas, los cuales generan una diferencia de potencial que depende
de la temperatura aplicada a ella. Esta es una propiedad que se conoce con el nombre de
efecto Seebeck, efecto termoeléctrico descubierto a inicios de la segunda década del siglo
dieciocho por Thomas Johann Seebeck.
Hoy en día se fabrican diferentes tipos de termocuplas, las cuales han sido clasificadas
según ciertas características propias de cada metal. Podemos conseguir en el mercado
termocuplas tipo B, J, K, E, N, R y S. Las termocuplas tipo J y tipo K son las más comunes
debido a que poseen características como una alta sensibilidad, en el rango de 40 uV/ºC a
52 uV/ºC aproximadamente, además de un alto rango de temperaturas que pueden ser
medidas.
Los metales correspondientes a la termocupla tipo J son el hierro y el constantán. Su rango
de temperatura es de -200ºC hasta 750ºC.
Los metales correspondientes a la termocupla tipo K son el cromo y el aluminio. Su rango de
temperatura es de -200ºC hasta 1250ºC.
Resulta muy importante mencionar que el voltaje generado por la unión de estos metales no
es lineal, con respecto al rango de temperatura medido. Para solucionar este inconveniente,
utilizaremos un amplificador-compensador entre la termocupla y el microcontrolador:
Figura 8.30 (Fuente: hoja de datos del dispositivo AD594/AD595)

_______________________________________________________________________________________
235
8.3.1.- AD594/AD595, cálculo de la linealidad.
Veamos como se resuelve el problema de linealidad en estos dispositivos.
El AD594 es un amplificador-compensador para termocuplas tipo J, y el AD595 es un
amplificador-compensador para termocuplas tipo K. Estos dispositivos generan en su salida
10 mV/ºC. Debido a que sabemos el voltaje que generan las uniones en las termocuplas tipo
J y K, podemos hallar la ganancia de salida del amplificador fácilmente:
Para una termocupla tipo J, el voltaje generado por la unión de sus metales es de 51.7
uV/ºC. Si calculamos la ganancia del amplificador en AD594, tenemos que:
C
mV
C
mV
Ganancia
/º
0517
.
0
/º
10
= 193.42
Para una termocupla tipo K, el voltaje generado por la unión de sus metales es de 40.44
uV/ºC. Si calculamos la ganancia del amplificador en AD595, tenemos que:
C
mV
C
mV
Ganancia
/º
04044
.
0
/º
10
= 247.27
La no linealidad se produce cuando aplicamos el voltaje generado por las termocuplas en la
entrada del amplificador operacional. Esta acción un induce un desplazamiento de entrada
con respecto a la de salida del amplificador de 16 uV para el AD594, y de 11 uV para el
AD595.
El AD594 y el AD595 están calibrados de fábrica para generar un voltaje igual a 250mV en
su salida cuando aplicamos una temperatura de 25ºC en la unión de las termocuplas.
Para compensar este desplazamiento, el AD594 realiza el cálculo del voltaje en su salida en
base a la siguiente formula:
Salida en AD594 = (Voltaje de Termocupla tipo J + 16uV) * Ganancia
Veamos un ejemplo numérico suponiendo que aplicamos una temperatura ideal de 30ºC en
una termocupla tipo J. El valor correspondiente al voltaje generado por la unión de los
metales en la termocupla tipo J se especifica en una tabla de valores publicada por la norma
IEC 584 (IEC es el acrónimo de International Electrotechnical Commission), Figura 8.31.
1. Según la tabla de la figura 8.31, sabemos que una termocupla tipo J genera 1536 uV
a una temperatura de 30ºC.
2. Además sabemos que la ganancia del amplificador es igual a 193.42
Entonces,
Salida en AD594 = (1536 uV + 16uV) * 193.42

_______________________________________________________________________________________
236
Salida en AD594 = 1552 uV * 193.42
Salida en AD594 = 300187.84 uV
Tabla de valores de voltajes de una termocupla tipo J
Temp
ºC
0 1 2 3 4 5 6 7 8 9 10
-220 -8096
-210 -8096 -8076 -8057 -8037 -8017 -7996 -7976 -7955 -7934 -7912 -7890
-200 -7890 -7868 -7846 -7824 -7801 -7778 -7755 -7731 -7707 -7683 -7659
-190 -7659 -7634 -7609 -7584 -7559 -7533 -7508 -7482 -7455 -7429 -7402
-180 -7402 -7375 -7348 -7321 -7293 -7265 -7237 -7209 -7180 -7151 -7122
-170 -7122 -7093 -7064 -7034 -7004 -6974 -6944 -6914 -6883 -6852 -6821
-160 -6821 -6790 -6758 -6727 -6695 -6663 -6630 -6598 -6565 -6532 -6499
-150 -6499 -6466 -6433 -6399 -6365 -6331 -6297 -6263 -6228 -6194 -6159
-140 -6159 -6124 -6089 -6053 -6018 -5982 -5946 -5910 -5874 -5837 -5801
-130 -5801 -5764 -5727 -5690 -5653 -5615 -5578 -5540 -5502 -5464 -5426
-120 -5426 -5388 -5349 -5311 -5272 -5233 -5194 -5155 -5115 -5076 -5036
-110 -5036 -4996 -4956 -4916 -4876 -4836 -4795 -4755 -4714 -4673 -4632
-100 -4632 -4591 -4550 -4508 -4467 -4425 -4383 -4341 -4299 -4257 -4215
-90 -4215 -4172 -4130 -4087 -4044 -4001 -3958 -3915 -3872 -3829 -3785
-80 -3785 -3742 -3698 -3654 -3610 -3566 -3522 -3478 -3433 -3389 -3344
-70 -3344 -3299 -3255 -3210 -3165 -3120 -3074 -3029 -2984 -2938 -2892
-60 -2892 -2847 -2801 -2755 -2709 -2663 -2617 -2570 -2524 -2478 -2431
-50 -2431 -2384 -2338 -2291 -2244 -2197 -2150 -2102 -2055 -2008 -1960
-40 -1960 -1913 -1865 -1818 -1770 -1722 -1674 -1626 -1578 -1530 -1481
-30 -1481 -1433 -1385 -1336 -1288 -1239 -1190 -1141 -1093 -1044 -995
-20 -995 -945 -896 -847 -798 -748 -699 -650 -600 -550 -501
-10 -501 -451 -401 -351 -301 -251 -201 -151 -101 -50 0
0 0 50 101 151 202 253 303 354 405 456 507
10 507 558 609 660 711 762 813 865 916 967 1019
20 1019 1070 1122 1174 1225 1277 1329 1381 1432 1484 1536
30 1536 1588 1640 1693 1745 1797 1849 1901 1954 2006 2058
40 2058 2111 2163 2216 2268 2321 2374 2426 2479 2532 2585
50 2585 2638 2691 2743 2796 2849 2902 2956 3009 3062 3115
60 3115 3168 3221 3275 3328 3381 3435 3488 3542 3595 369
70 369 3702 3756 3809 3863 3917 3971 4024 4078 4132 4186
80 4186 4239 4293 4347 4401 4455 4509 4563 4617 4671 4725
90 4725 4780 4834 4888 4942 4996 5050 5105 5159 5213 5268
100 5268 5322 5376 5431 5485 5540 5594 5649 5703 5758 5812
110 5812 5867 5921 5976 6031 6085 6140 6195 6249 6304 6359
120 6359 6414 6468 6523 6578 6633 6688 6742 6797 6852 6907
130 6907 6962 7017 7072 7127 7182 7237 7292 7347 7402 7457
140 7457 7512 7567 7622 7677 7732 7787 7843 7898 7953 8008
Salida en AD594 = 300 mV.

_______________________________________________________________________________________
237
150 8008 8063 8118 8174 8229 8284 8339 8394 850 8505 8560
160 8560 8616 8671 8726 8781 8837 8892 8947 9003 9058 9113
170 9113 9169 9224 9279 9335 9390 9446 9501 9556 9612 9667
180 9667 9723 9778 9834 9889 9944 10000 10055 10111 10166 10222
190 10222 10277 10333 10388 10444 10499 10555 10610 10666 10721 10777
200 10777 10832 10888 10943 10999 11054 11110 11165 11221 11276 11332
210 11332 11387 11443 11498 11554 11609 11665 11720 11776 11831 11887
220 11887 11943 11998 12054 12109 12165 12220 12276 12331 12387 12442
230 12442 12498 12553 12609 12664 12720 12776 12831 12887 12942 12998
240 12998 13053 13109 13164 13220 13275 13331 13386 13442 13497 13553
250 13553 13608 13664 13719 13775 13830 13886 13941 13997 14052 14108
260 14108 14163 14219 14274 14330 14385 14441 14496 14552 14607 14663
270 14663 14718 14774 14829 14885 14940 14995 15051 15106 15162 15217
280 15217 15273 15328 15383 15439 15494 15550 15605 15661 15716 15771
290 15771 15827 15882 15938 15993 16048 16104 16159 16214 16270 16325
300 16325 16380 16436 16491 16547 16602 16657 16713 16768 16823 16879
310 16879 16934 16989 17044 17100 17155 17210 17266 17321 17376 17432
320 17432 17487 17542 17597 17653 17708 17763 17818 17874 17929 17984
330 17984 18039 18095 18150 18205 18260 18316 18371 18426 18481 18537
340 18537 18592 18647 18702 18757 18813 18868 18923 18978 19033 19089
350 19089 19144 19199 19254 19309 19364 1920 19475 19530 19585 19640
360 19640 19695 19751 19806 19861 19916 19971 20026 20081 20137 20192
370 20192 20247 20302 20357 20412 20467 20523 20578 20633 20688 20743
380 20743 20798 20853 20909 20964 21019 21074 21129 21184 21239 21295
390 21295 21350 21405 21460 21515 21570 21625 21680 21736 21791 21846
400 21846 21901 21956 22011 22066 22122 22177 22232 22287 22342 22397
410 22397 22453 22508 22563 22618 22673 22728 22784 22839 22894 22949
420 22949 23004 23060 23115 23170 23225 23280 23336 23391 23446 23501
430 23501 23556 23612 23667 23722 23777 23833 23888 23943 23999 24054
440 24054 24109 24164 24220 24275 24330 24386 24441 24496 24552 24607
450 24607 24662 24718 24773 24829 24884 24939 24995 25050 25106 25161
460 25161 25217 25272 25327 25383 25438 25494 25549 25605 25661 25716
470 25716 25772 25827 25883 25938 25994 26050 26105 26161 26216 26272
480 26272 26328 26383 26439 26495 26551 26606 26662 26718 26774 26829
490 26829 26885 26941 26997 27053 27109 27165 27220 27276 27332 27388
500 27388 27444 27500 27556 27612 27668 27724 27780 27836 27893 27949
510 27949 28005 28061 28117 28173 28230 28286 28342 28398 28455 28511
520 28511 28567 28624 28680 28736 28793 28849 28906 28962 29019 29075
530 29075 29132 29188 29245 29301 29358 29415 29471 29528 29585 29642
540 29642 29698 29755 29812 29869 29926 29983 30039 30096 30153 30210
550 30210 30267 30324 30381 30439 30496 30553 30610 30667 30724 30782
560 30782 30839 30896 30954 31011 31068 31126 31183 31241 31298 31356
570 31356 31413 31471 31528 31586 31644 31702 31759 31817 31875 31933
580 31933 31991 32048 32106 32164 32222 32280 32338 32396 32455 32513
590 32513 32571 32629 32687 32746 32804 32862 32921 32979 33038 33096
600 33096 33155 33213 33272 33330 33389 33448 33506 33565 33624 33683
610 33683 33742 33800 33859 33918 33977 34036 34095 34155 34214 34273
620 34273 34332 34391 34451 34510 34569 34629 34688 3478 34807 34867
630 34867 34926 34986 35046 35105 35165 35225 35285 35344 35404 35464
640 35464 35524 35584 35644 35704 35764 35825 35885 35945 36005 36066

_______________________________________________________________________________________
238
650 36066 36126 36186 36247 36307 36368 36428 36489 36549 36610 36671
660 36671 36732 36792 36853 36914 36975 37036 37097 37158 37219 37280
670 37280 37341 37402 37463 37525 37586 37647 37709 37770 37831 37893
680 37893 37954 38016 38078 38139 38201 38262 38324 38386 38448 38510
690 38510 38572 38633 38695 38757 38819 38882 38944 39006 39068 39130
700 39130 39192 39255 39317 39379 39442 39504 39567 39629 39692 39754
710 39754 39817 39880 39942 40005 40068 40131 40193 40256 40319 40382
720 40382 40445 40508 40571 40634 40697 40760 40823 40886 40950 41013
730 41013 41076 41139 41203 41266 41329 41393 41456 41520 41583 41647
740 41647 41710 41774 41837 41901 41965 42028 42092 42156 42219 42283
750 42283 42347 42411 42475 42538 42602 42666 42730 42794 42858 42922
760 42922 42980 43050 43114 43178 43242 43306 43370 43435 43499 43563
770 43563 43627 43692 43756 43820 43885 43949 44014 44078 44142 44207
780 44207 44271 44336 44400 44465 44529 44594 44658 44723 44788 44852
790 44852 44917 44981 45046 45111 45175 45240 45304 45369 45434 45498
800 45498 45563 45627 45692 45757 45821 45886 45950 46015 46080 46144
810 46144 46209 46273 46338 46403 46467 46532 46596 46661 46725 46790
820 46790 6854 46919 46983 47047 47112 47176 47241 47305 47369 47434
830 47434 47498 47562 47627 47691 47755 47819 47884 47948 48012 48076
840 48076 48140 48204 48269 48333 48397 48461 48525 48589 48653 48716
850 48716 48780 48844 48908 48972 49036 49099 49163 49227 49291 49354
860 49354 49418 49481 49545 49608 49672 49735 49799 49862 49926 49989
870 49989 50052 50116 50179 50242 50305 50369 50432 50495 50558 50621
880 50621 50684 50747 50810 50873 50936 50998 51061 51124 51187 51249
890 51249 51312 51375 51437 51500 51562 51625 51687 51750 51812 51875
900 51875 51937 51999 52061 52124 52186 52248 52310 52372 52434 52496
910 52496 52558 52620 52682 52744 52806 52868 52929 52991 53053 53115
920 53115 53176 53238 53299 53361 53422 53484 53545 53607 53668 53729
930 53729 53791 53852 53913 53974 54035 54096 54157 54219 54280 54341
940 54341 54401 54462 54523 54584 54645 54706 54766 54827 54888 54948
950 54948 55009 55070 55130 55191 55251 55312 55372 55432 55493 55553
960 55553 55613 55674 55734 55794 55854 55914 55974 56035 56095 56155
970 56155 56215 56275 56334 56394 56454 56514 56574 56634 56693 56753
980 56753 56813 56873 56932 56992 57051 57111 57170 57230 57289 57349
990 57349 57408 57468 57527 57586 57646 57705 57764 57824 57883 57942
1000 57942 58001 58060 58120 58179 58238 58297 58356 58415 58474 58533
1010 58533 58592 58651 58710 58769 58827 58886 58945 59004 59063 59121
1020 59121 59180 59239 59298 59356 59415 59474 59532 59591 59650 59708
1030 59708 59767 59825 59884 59942 60001 60059 60118 60176 60235 60293
1040 60293 60351 60410 60468 60527 60585 60643 60702 60760 60818 60876
1050 60876 60935 60993 61051 61109 61168 61226 61284 61342 61400 61459
1060 61459 61517 61575 61633 61691 61749 61807 61865 61923 61981 62039
1070 62039 62097 62156 62214 62272 62330 62388 62446 62504 62562 62619
1080 62619 62677 62735 62793 62851 62909 62967 63025 63083 63141 63199
1090 63199 63257 63314 63372 63430 63488 63546 63604 63662 63719 63777
1100 63777 63835 63893 63951 64009 64066 64124 64182 64240 64298 64355
1110 64355 64413 64471 64529 64586 64644 64702 64760 64817 64875 64933
1120 64933 64991 65048 65106 54164 65222 65279 65337 65395 65453 65510
1130 65510 65568 65626 65683 65741 65799 65856 65914 65972 66029 66087
1140 66087 66145 66202 66260 66318 66375 66433 66491 66548 66606 66664

_______________________________________________________________________________________
239
1150 66664 66721 66779 66836 66894 66952 67009 67067 67124 67182 67240
1160 67240 67297 67355 67412 67470 67527 67585 67643 67700 67758 67815
1170 67815 67873 67930 67988 68042 68103 68160 68217 68275 68332 68390
1180 68390 68447 68505 68562 68619 68677 68734 68792 68849 68906 68964
1190 68964 69021 69078 69135 69193 69250 69307 69364 69422 69479 69536
1200 69536
Figura 8.31
El AD595 realiza el cálculo del voltaje en su salida en base a la siguiente formula:
Salida en AD595 = (Voltaje de Termocupla tipo K + 11 uV) * Ganancia
Veamos un ejemplo numérico suponiendo que aplicamos una temperatura ideal de 160ºC en
una termocupla tipo K. El valor correspondiente al voltaje generado por la unión de los
metales en la termocupla tipo K se especifica en una tabla de valores publicada por la norma
IEC 584 (IEC es el acrónimo de International Electrotechnical Commission), Figura 8.32.
3. Según la tabla de la figura 8.32, sabemos que una termocupla tipo K genera 6539 uV
a una temperatura de 160ºC.
4. Sabemos que la ganancia del amplificador es igual a 247.27
Entonces,
Salida en AD594 = (6539 uV + 11uV) * 247.27
Salida en AD594 = 6550 uV * 247.27
Salida en AD594 = 1619618.5 uV
Salida en AD595 = 1619.6 mV

_______________________________________________________________________________________
240
Tabla de valores de voltajes de una termocupla tipo K
Temp
ºC
0 1 2 3 4 5 6 7 8 9 10
-270 -6458 -6457 -6456 -6455 -6453 -6452 -6450 -6448 -6446 -6444 -6461
-260 -6441 -6438 -6435 -6432 -6429 -6425 -6421 -6417 -6413 -6408 -6404
-250 -6404 -6399 -6394 -6388 -6382 -6377 -6371 -6364 -6358 -6351 -6344
-240 -6344 -6337 -6329 -6322 -6314 -6306 -6297 -6289 -6280 -6271 -6262
-230 -6262 -6253 -6243 -6233 -6223 -6213 -6202 -6192 -6181 -6170 -6158
-220 -6158 -6147 -6135 -6123 -6111 -6099 -6087 -6074 -6061 -6048 -6035
-210 -6035 -621 -6007 -5994 -5980 -5965 -5951 -5936 -5922 -5907 -5891
-200 -5891 -5876 -5860 -5845 -5829 -5813 -5796 -5780 -5763 -5747 -5730
-190 -5730 -5712 -5695 -5678 -566 -5642 -5624 -5606 -5587 -5569 -5550
-180 -5550 -5531 -5512 -5493 -5474 -5454 -5434 -5414 -5394 -5374 -5354
-170 -5354 -5333 -5313 -5292 -5271 -5249 -5228 -5207 -5185 -5163 -5141
-160 -5141 -5119 -5097 -5074 -5051 -5029 -5006 -4983 -4959 -4936 -4912
-150 -4912 -4889 -4865 -4841 -4817 -4792 -4768 -4743 -4719 -4694 -4669
-140 -4669 -4644 -4618 -4593 -4567 -4541 -4515 -4489 -4463 -4437 -4410
-130 -4410 -4384 -4357 -4330 -4303 -4276 -4248 -4221 -4193 -4166 -4138
-120 -4138 -4110 -4082 -4053 -4025 -3997 -3968 -3939 -3910 -3881 -3852
-110 -3852 -3823 -3793 -3764 -3734 -3704 -3674 -3644 -3614 -3584 -3553
-100 -3553 -3523 -3492 -3461 -3430 -3399 -3368 -3337 -3305 -3274 -3242
-90 -3242 -3211 -3179 -3147 -3115 -3082 -3050 -3018 -2985 -2953 -2920
-80 -2920 -2887 -2584 -2821 -2788 -2754 -2721 -2687 -2654 -2620 -2586
-70 -2586 -2552 -2518 -2484 -2450 -2416 -2381 -2347 -2312 -2277 -2243
-60 -2243 -2208 -2173 -2137 -2102 -2067 -2032 -1996 -1961 -1925 -1889
-50 -1889 -1853 -1817 -1781 -1745 -1709 -1673 -1636 -1600 -1563 -1527
-40 -1527 -1490 -1453 -1416 -1379 -1342 -135 -1268 -1231 -1193 -1156
-30 -1156 -1118 -1081 -1043 -1005 -968 -930 -892 -854 -816 -777
-20 -777 -739 -701 -6621 -624 -585 -547 -508 -469 -431 -392
-10 -392 -353 -314 -275 -236 -197 -157 -118 -79 -39 0
0 0 39 79 119 158 198 238 277 317 357 397
10 397 437 477 517 557 597 637 677 718 758 798
20 798 838 879 919 960 1000 1041 1081 1122 1162 1203
30 1203 1244 1285 1325 1366 1407 1448 1489 1529 1570 1611
40 1611 1652 1693 1734 1776 1817 1858 1899 1940 1981 2022
50 2022 2064 2105 2146 2188 2229 2270 2312 2353 2394 2436
60 2436 2477 21519 2560 2601 2643 2684 2726 2767 2809 2850
70 2850 2892 2933 2975 3016 3058 3100 3141 3183 3224 3266
80 3266 3307 3349 3390 3432 3473 3515 3556 3598 3639 3681
90 3681 3722 3764 3805 3847 3888 3930 3971 4012 4054 4095
100 4095 4137 4178 4219 4261 4302 4343 4384 4426 4467 4508
110 4508 4549 4590 4632 4673 4714 4755 4796 4837 4878 4919
120 4919 4960 5001 5042 5083 5124 5164 5205 5246 5287 5327
130 5327 5368 5409 5450 5490 5531 5571 5612 5652 5693 5733
140 5733 5774 5814 5855 5895 5936 5976 6016 6057 6097 6137
150 6137 6177 6218 6258 6298 6338 6378 6419 6459 6499 6539
160 6539 6579 6619 6659 6699 6739 6779 6819 6859 6899 6939
170 6939 6979 7019 7059 7099 7139 7179 7219 7259 7299 7338
180 7338 7378 7418 7458 7498 7538 7578 7618 7658 7697 7737
190 7737 7777 7817 7857 7897 7937 7977 8017 8057 8097 8137

_______________________________________________________________________________________
241
200 8137 8177 8216 8256 8296 8336 7276 8416 8456 8497 8537
210 8537 8577 8617 8657 8697 8737 8777 8817 8857 8898 8938
220 8938 8978 9018 9058 9099 9139 9179 9220 9260 9300 9341
230 9341 9381 9421 9462 9502 9543 9583 9624 9664 9705 9745
240 9745 9786 9826 9867 9907 9948 9989 10029 10070 10111 10151
250 10151 10192 10233 10274 10315 10355 10396 10437 10478 10519 10560
260 10560 10600 10641 10682 10723 10764 10805 10846 10887 10928 10969
270 10969 11010 11051 11093 11134 11175 11216 11257 11298 11339 11381
280 11381 11422 11463 11504 11546 11587 11628 11669 11711 11752 11793
290 11793 11835 11876 11918 11959 12000 12042 12083 12125 12166 12207
300 12207 12249 12290 12332 12373 12415 12456 12498 12539 12581 12623
310 12623 12664 12706 12747 12789 12831 12872 12914 12955 12997 13039
320 13039 13080 13122 13164 13205 13247 13289 13331 13372 13414 13456
330 13456 13497 13539 13581 16623 13665 13706 13748 13790 13832 13874
340 13874 13915 13597 13999 14041 14083 14125 14167 14208 14250 14292
350 14292 14334 14376 14418 14460 1452 14544 14586 14628 14670 14712
360 14712 14754 14796 14838 14880 14922 14964 15006 15048 15090 15132
370 15132 15174 15216 15258 15300 15342 15384 15426 15468 15510 15552
380 15552 15594 15636 15679 15721 15763 15805 15847 15889 15931 15974
390 15974 16016 16058 16100 16142 16184 16227 16269 16311 16353 16395
400 16395 16438 16480 16522 16564 16607 16649 16691 16733 16776 16818
410 16818 16860 1692 16945 16987 17029 17072 17114 17156 17199 17241
420 17241 17283 17326 17368 17410 17453 17495 17537 17580 17622 17664
430 17664 17707 17749 17792 17834 17876 17919 17961 18004 18046 18088
440 18088 18131 18173 18216 18258 18301 18343 18385 18428 18470 18513
450 18513 18555 18598 18640 18683 18725 18768 18810 18853 18895 18938
460 18938 18980 19023 19065 19108 19150 19193 19235 19278 19320 19363
470 19363 19405 19448 19490 19533 19576 19618 19661 19703 19746 19788
480 19788 19831 19873 19916 19959 20001 20044 20086 20129 20172 20214
490 20214 20257 20299 20342 20385 20427 2070 20512 20555 20598 20640
500 20640 20683 20725 2768 20811 20853 20896 20938 20981 21024 21066
510 21066 21109 21152 21194 21237 21280 21322 21365 21407 21450 21493
520 21493 21535 21578 21621 21663 21706 21749 21791 21834 21876 21919
530 21919 21962 22004 22047 22090 22132 22175 22218 22260 22303 22346
540 22346 22388 22431 22473 22516 22559 22601 22644 22687 22729 22772
550 22772 22815 22857 22900 22942 22985 23028 23070 23113 23156 23198
560 23198 23241 23284 23326 23369 23411 23454 23497 23539 23582 23624
570 23624 23667 23710 23752 23795 23837 23880 23923 23965 24008 24050
580 24050 24093 24136 24178 24221 2263 24306 24348 24391 24434 24476
590 24476 24519 24561 24604 24646 24689 24731 24774 24817 24859 2492
600 24902 24944 24987 25029 25072 25114 25157 25199 25242 25284 25327
610 25327 25396 25412 25454 25497 25539 25582 25624 25666 25709 25751
620 25751 25794 25836 25879 25921 25964 26006 26048 2691 26133 26176
630 26176 26218 26260 26303 26345 26387 26430 26472 26515 26557 26599
640 26599 26642 26684 26726 26769 26811 26853 26896 26938 26980 27022
650 27022 27065 27107 27149 27192 27234 27276 27318 27361 27403 27445
660 27445 27487 27529 27572 27614 27656 27698 27740 27783 27825 27867
670 27867 27909 27951 27993 28035 28078 28120 28162 28204 28246 28288
680 28288 28330 28372 28414 28456 28498 28540 28583 28625 28667 28709
690 28709 28751 28793 28835 28877 28919 28961 29002 29044 29086 29128

_______________________________________________________________________________________
242
700 29128 29170 29212 29254 29296 29338 29380 29422 29464 29505 29547
710 29547 29589 29631 29673 29715 29756 29798 2980 29882 29924 29965
720 29965 30007 30049 30091 30132 30174 30216 30257 30299 30341 30383
730 30383 30424 30466 30508 30549 30591 3632 30674 30716 30757 30799
740 30799 30840 30882 30924 3965 31007 31048 31090 31131 31173 31214
750 31214 31256 31297 31339 3138 31422 31463 31504 31546 31587 31629
760 31629 31670 31712 31753 31794 31836 31877 31918 31960 32001 32042
770 32042 32084 32125 32166 32207 32249 32290 32331 32372 32414 32455
780 32455 32496 32537 32578 329619 32661 32702 32743 32784 32825 32866
790 32866 32907 32948 32990 33031 33072 33113 33154 33195 33236 33277
800 33277 33318 33359 33400 33441 33482 33523 33564 33604 33645 33686
810 33686 33727 33768 33809 33850 33891 33931 33972 34013 34054 34095
820 34095 34136 34176 34217 34258 34299 34339 34380 34421 34461 34502
830 34502 34543 34583 34624 34665 34705 34746 34787 34827 34868 34909
840 34909 34949 34990 35030 35071 35111 35152 35192 35233 35273 35314
850 35314 35354 35395 35435 35476 35516 35557 35597 35637 35678 35718
860 35718 35758 35799 35839 35880 35920 35960 36000 36041 36081 36121
870 36121 36162 36202 36242 36282 36323 36363 36403 36443 36483 36524
880 36524 36564 36604 36644 36684 36724 36764 36804 36844 36885 36925
890 36925 36965 37005 37045 37085 37125 37165 3725 37245 37285 37325
900 37325 37365 27405 37445 37484 37524 37564 37604 37644 37684 37724
910 37724 37764 37803 37843 37883 37923 37963 38002 38042 38082 38122
920 38122 38162 38201 38241 38281 38320 38360 38400 38439 38479 38519
930 38519 38558 38598 38638 38677 38717 38756 38796 38836 38875 38915
940 38915 38954 38994 39033 39073 39112 39152 39191 39231 39270 39310
950 39310 39349 39388 39428 39467 39507 39546 39585 39625 39664 39703
960 39703 39743 39782 39821 39861 39900 39939 39979 40018 40057 40096
970 40096 40136 40175 4021 40253 40292 40332 40371 40410 40449 40488
980 40488 40527 40566 40605 40645 40684 40723 40762 40801 40840 40879
990 40879 40918 40957 40996 41035 41074 41113 41152 41191 41230 41269
1000 41269 41308 41347 41385 41424 41463 41502 41541 41580 41619 41657
1010 41657 41696 41735 41774 41813 41851 41890 41929 41968 42006 42045
1020 42045 42084 42123 42161 42200 42239 42277 42316 42355 42393 42432
1030 42432 42470 42509 42548 42586 42625 42663 42702 42740 42779 42817
1040 42817 42856 42894 42933 42971 43010 43048 43087 43125 43164 43202
1050 43202 43240 43279 43317 43356 43394 43432 43471 43509 43547 43585
1060 43585 43624 43662 43700 43739 43777 43815 43853 43891 43930 43968
1070 43968 44006 44044 44082 44121 44159 44198 44235 44273 44311 44349
1080 44349 44387 44425 44463 44501 44539 44577 44615 44653 44691 44729
1090 44729 44767 44805 44843 44881 44919 44957 44995 45033 45070 45108
1100 45108 45146 45184 45222 45260 45297 45335 45373 45411 45448 45486
1110 45486 45524 45561 45599 45637 45675 45712 45750 45787 45825 45863
1120 45863 45900 45938 45975 46013 46051 46088 46126 46163 46201 46238
1130 46238 46275 46313 46350 46388 46425 46463 46500 46537 46575 46612
1140 46612 46649 46687 46724 46761 46799 46836 46873 46910 46948 46985
1150 46985 47022 47059 47096 47134 47171 47208 47245 47282 47319 47356
1160 47356 47393 47430 47468 47505 47542 47579 47616 47653 47689 47726
1170 47726 47763 47800 47837 47874 47911 47948 47985 48021 48058 48095
1180 48095 48132 48169 48205 48242 48279 48316 48352 48389 48426 48462
1190 48462 48499 48536 48572 48609 48645 48682 48718 48755 48792 48828

_______________________________________________________________________________________
243
1200 48828 48865 48901 48937 48974 49010 49047 49083 49120 49156 49192
1210 49192 49229 49265 49301 49338 49374 49410 49446 49483 49519 49555
1220 49555 49591 49627 49663 49700 49736 49772 49808 49844 49880 49916
1230 49916 49952 49988 50024 50060 50096 50132 50168 50204 50240 50276
1240 50276 50311 50347 50383 50419 50455 50491 50526 50562 50598 50633
1250 50633 50669 50705 50741 50776 50812 50847 50883 50919 50954 50990
1260 50990 51025 51061 51096 51132 51167 51203 51238 51274 51309 51344
1270 51344 51380 51415 51450 51486 51521 51556 51592 51627 51662 51697
1280 51697 51733 51768 51803 51838 51873 51908 51943 51979 5201 52049
1290 52049 52084 52119 52154 52189 52224 52259 52294 52329 52364 52398
1300 52398 52433 52468 52503 52538 52573 52608 52642 52677 52712 52747
1310 52747 52781 52816 52851 52886 52920 52955 52989 53024 53059 53093
1320 53093 53128 53162 53197 53232 53266 53301 53335 53370 53404 53439
1330 53439 53473 53507 53542 53576 53611 53645 53679 53714 53748 53782
1340 53782 53817 553851 53885 53920 53954 53988 54022 54057 54091 54125
1350 54125 54159 54193 54228 54262 54296 54330 54364 54398 54432 54466
Figura 8.32
Veamos a continuación una tabla la cual refleja los valores calculados en intervalos cortos
de temperaturas para las termocuplas tipo J y tipo K, correspondientes a los dispositivos
AD594 y AD595:
Temperatura en
Termocupla en ºC
Tipo J - Voltaje
en mV
AD594 Voltaje
de Salida
Tipo K - Voltaje
en mV
AD595 Voltaje
de Salida
–200 –7.890 –1523 –5.891 –1454
–180 –7.402 –1428 –5.550 –1370
–160 –6.821 –1316 –5.141 –1269
–140 –6.159 –1188 –4.669 –1152
–120 –5.426 –1046 –4.138 –1021
–100 –4.632 –893 –3.553 –876
–80 –3.785 –729 –2.920 –719
–60 –2.892 –556 –2.243 –552
–40 –1.960 –376 –1.527 –375
–20 –.995 –189 –.777 –189
–10 –.501 –94 –.392 –94
0 0 3.1 0 2.7
10 .507 101 .397 101
20 1.019 200 .798 200
25 1.277 250 1.000 250
30 1.536 300 1.203 300
40 2.058 401 1.611 401
50 2.585 503 2.022 503
60 3.115 606 2.436 605
80 4.186 813 3.266 810
100 5.268 1022 4.095 1015
120 6.359 1233 4.919 1219

_______________________________________________________________________________________
244
140 7.457 1445 5.733 1420
160 8.560 1659 6.539 1620
180 9.667 1873 7.338 1817
200 10.777 2087 8.137 2015
220 11.887 2302 8.938 2213
240 12.998 2517 9.745 2413
260 14.108 2732 10.560 2614
280 15.217 2946 11.381 2817
300 16.325 3160 12.207 3022
320 17.432 3374 13.039 3227
340 18.537 3588 13.874 3434
360 19.640 3801 14.712 3641
380 20.743 4015 15.552 3849
400 21.846 4228 16.395 4057
420 22.949 4441 17.241 4266
440 24.054 4655 18.088 4476
460 25.161 4869 18.938 4686
480 26.272 5084 19.788 4896
500 27.388 5300 20.640 5107
520 28.511 5517 21.493 5318
540 29.642 5736 22.346 5529
560 30.782 5956 23.198 5740
580 31.933 6179 24.050 5950
600 33.096 6404 24.902 6161
620 34.273 6632 25.751 6371
640 35.464 6862 26.599 6581
660 36.671 7095 27.445 6790
680 37.893 7332 28.288 6998
700 39.130 7571 29.128 7206
720 40.382 7813 29.965 7413
740 41.647 8058 30.799 7619
750 42.283 8181 31.214 7722
760 – – 31.629 7825
780 – – 32.455 8029
800 – – 33.277 8232
820 – – 34.095 8434
840 – – 34.909 8636
860 – – 35.718 8836
880 – – 36.524 9035
900 – – 37.325 9233
920 – – 38.122 9430
940 – – 38.915 9626
960 – – 39.703 9821
980 – – 40.488 10015
1000 – – 41.269 10209
1020 – – 42.045 10400
1040 – – 42.817 10591
1060 – – 43.585 10781
1080 – – 44.439 10970
1100 – – 45.108 11158

_______________________________________________________________________________________
245
1120 – – 45.863 11345
1140 – – 46.612 11530
1160 – – 47.356 11714
1180 – – 48.095 11897
1200 – – 48.828 12078
1220 – – 49.555 12258
1240 – – 50.276 12436
1250 – – 50.633 12524
Figura 8.33
De esta forma el problema de la linealidad en el voltaje de salida está resuelto, de modo que
ahora podemos realizar la conversión de la salida analógica de los dispositivos AD594 o
AD595 según sea el caso, a través del conversor A/D del microcontrolador.

_______________________________________________________________________________________
246
Utilizaremos para el ejemplo de programación una termocupla tipo J con su respectivo
amplificador-compensador AD594, cuya configuración básica veremos a continuación,
además de una característica adicional que nos ayudará a determinar si la termocupla
conectada al circuito se ha fallado ya sea por corrosión o desgaste tras soportar altas
temperaturas durante un tiempo determinado.
Figura 8.34
El pin RC0 del puesto “C” será configurado como entrada para evaluar constantemente la
alarma de fallo de la termocupla del AD594. Los pines 12 y 13 (+ALM y –ALM
respectivamente) son el colector y el emisor de un transistor NPN interno, el cual se activa al
producirse una falla en el circuito.
En el circuito de la figura 8.34, el pin “+ALM” mantiene un estado lógico alto gracias a la
resistencia “Pull Up” de 1K, lo cual significa que se mantiene un estado lógico alto en RC0
mientras la termocupla se encuentra conectada y funcionando. Cuando se produce una falla,
el AD594 activa el transistor y el estado lógico en RC0 pasa a ser bajo o “cero”, debido a
que el emisor en el transistor (pin -ALM) se encuentra conectado a tierra.

_______________________________________________________________________________________
247
program Termocupla
' conversión A/D.
Dim Temp As Float
main:
ADCON1 = 0 ' Configura el puerto A como puerto analógico,
TRISC = $FF ' Configura el puerto C como entrada.
While (TRUE)
Temp = (dato * 4.9) / 10 ' Calculamos la Temperatura de TC-J.
FloatToStr(Temp, DatoStr) ' Conversión de Float a String
texto = "Temperatura: " ' Cargamos la variable con un mensaje.
Lcd_Out(1, 1, texto) ' Escribimos el contenido de la variable.
Lcd_Out(2, 1, DatoStr) ' Escribimos el resultado de la conversión.
Lcd_Out(2, 11, "oC ") ' Escribimos la unidad de temperatura "ºC".
If PortC.0 = 0 Then ' Verificamos si la alarma del AD594 se ha activado.
GoTo Alarma ' Si la termocupla falla, salta a la subrutina "Alarma".
End If
Wend
Alarma:
' Escribimos el mensaje de alarma.
Lcd_Out(1, 1, "* Alarma de TC *")
Lcd_Out(2, 1, "Circuito Abierto")
Espera:
If PortC.0 = 1 Then ' Verificamos si la alarma fué solucionada.
GoTo main ' Salta a la rutina principal del programa si la
End If ' termocupla funciona correctamente.

_______________________________________________________________________________________
248
GoTo Espera ' Si la termocupla sigue dañada, vuelve a verificar
' la alarma hasta que la termocupla sea reemplazada.
End.
Debido a que el voltaje de referencia del conversor A/D es igual al voltaje de alimentación
del circuito, es decir, +5 Vdc, la medida de la temperatura en este ejemplo se limita a un
rango aproximado de 0ºC a 460ºC.
En cuando al cálculo de la temperatura, primero es necesario saber el valor de la resolución
del conversor A/D en términos de voltaje. Como el voltaje de referencia es igual al de la
fuente de poder, entonces tenemos que:
Resolución = n
Vi
2
max
Resolución = 10
2
5V
Resolución =
1024
5V
Resolución = 0.00488 0.0049 V
Entonces, si por ejemplo tenemos una temperatura en la unión de la termocupla de 30ºC,
tendremos en la salida del AD594 un voltaje igual a 300 mV. Al convertir este voltaje a través
de conversor A/D de microcontrolador, el valor cargado en la variable “Dato” será
aproximadamente igual a 62, en el rango de conversión de 0 a 1023.
Ahora bien, si tenemos el valor de la conversión y el valor de la resolución en la conversión,
podremos calcular el valor del voltaje de entrada en RA2 y por consiguiente el valor de la
temperatura en la termocupla:
Voltaje en RA2 = Valor de la conversión A/D x Resolución
Voltaje en RA2 = 62 x 4.9 mV
Voltaje en RA2 = 303.8 mV

_______________________________________________________________________________________
249
Recordemos que el AD594 genera en su salida 10mV/ºC, por lo tanto:
Temperatura de TC-J =
C
mV /º
10
mV
4.9
x
A/D
conversión
la
de
Valor
Temperatura de TC-J =
C
mV
mV
/º
10
8
.
303
Temperatura de TC-J = 30.38 ºC.
El resultado del programa anterior es el siguiente:
Figura 8.35
Si desconectamos uno de los terminales de la termocupla, el mensaje en la pantalla será el
siguiente:
Figura 8.36

Microcontroladores: mikroBasic para microcontroladores PIC

Más contenido relacionado

La actualidad más candente (20)

Similar a Microcontroladores: mikroBasic para microcontroladores PIC (20)

Más de SANTIAGO PABLO ALBERTO (20)

Último (20)

Microcontroladores: mikroBasic para microcontroladores PIC