Pic problemas resueltos

LOS PIC DE LA GAMA MEDIA.
ARQUITECTURA Y TÉCNICAS DE
PROGRAMACIÓN.

Santiago Salamanca Miño
David Arroyo Muñoz

Octubre de 2003

Este libro es el resultado del Proyecto Fin de Carrera realizado por el alumno David
Arroyo Muñoz y dirigido por Santiago Salamanca Miño. Está basado en los apuntes de
clase de la asignatura Informática Industrial de la Titulación de Ingeniero Técnico
Industrial, especialidad Electrónica Industrial, que se imparte en la Escuela de
Ingenierías Industriales de la Universidad de Extremadura.

Agradecemos la información suministrada por Jorge Jesús Pérez García para la
corrección de este documento.

Si encuentras alguna errata o quieres hacer algún comentario, puedes escribir al
siguiente correo electrónico:
ssalaman@unex.es

Microcontroladores PIC de la Gama Media. ÍNDICE GENERAL.

ÍNDICE GENERAL

1 Introducción a los Microcontroladores. ..................................................................... 1
1.1 ¿Qué es un microcontrolador? ................................................................. 1
1.2 Aplicaciones............................................................................................. 3
1.3 Los microcontroladores PIC. ................................................................... 3
1.4 Las Gamas de los PIC.............................................................................. 5
1.5 Los PIC de la Gama Media...................................................................... 6
2 La Arquitectura de los PIC de la Gama Media......................................................... 11
2.1 Introducción. ........................................................................................... 11
2.2 Organización de la memoria. .................................................................. 13
2.2.1 Organización de la memoria de programa. ..................... 13
2.2.2 Organización de la memoria de datos............................. 16
2.2.3 Registros y recursos comunes......................................... 19
2.2.3.1 Registro de Estado. ....................................... 19
2.2.3.2 Registro de Opciones. ................................... 20
2.2.3.3 Palabra de configuración. ............................. 21
2.3 Oscilador................................................................................................. 22
2.4 Reset........................................................................................................ 26
2.5 Temporizador y Perro Guardián. ............................................................ 34
2.6 Puertas E/S.............................................................................................. 36
2.7 Modo de reposo o SLEEP....................................................................... 37
3 Juego de Instrucciones de los PIC de la Gama Media.............................................. 39
3.1 Introducción. ........................................................................................... 39
3.2 Flujo de instrucciones. Segmentación. ................................................... 40
3.3 El formato de las instrucciones............................................................... 41
3.4 Juego de instrucciones. ........................................................................... 43
3.4.1 Descripción detallada de las instrucciones
por orden alfabético. ....................................................... 45
4 Los Periféricos de los PIC de la Gama Media. ......................................................... 63
4.1 Introducción. ........................................................................................... 63

Santiago Salamanca Miño I Escuela de Ingenierías Industriales
David Arroyo Muñoz Universidad de Extremadura


4.2 Interrupciones. ........................................................................................ 63
4.2.1 Registros de control. ....................................................... 65
4.2.1.1 Registro INTCON......................................... 65
4.2.1.2 Registros PIE. ............................................... 66
4.2.1.3 Registros PIR. ............................................... 67
4.2.2 Fases de una interrupción. .............................................. 70
4.3 Puertas de E/S. ........................................................................................ 72
4.3.1 Puerta A. ......................................................................... 73
4.3.2 Puerta B. ......................................................................... 75
4.3.3 Puerta C. ......................................................................... 77
4.3.4 Puerta D. ......................................................................... 78
4.3.5 Puerta E........................................................................... 78
4.3.6 Puertas F y G. ................................................................. 79
4.3.7 Puerta GPIO.................................................................... 80
4.3.8 Operaciones sucesivas en un Puerto E/S. ....................... 81
4.4 Puerto Paralelo Esclavo. ......................................................................... 83
4.5 Temporizadores ...................................................................................... 86
4.5.1 TMR0.............................................................................. 86
4.5.2 TMR1.............................................................................. 90
4.5.3 TMR2.............................................................................. 92
4.6 Módulos CCP.......................................................................................... 93
4.6.1 Modo de captura. ............................................................ 94
4.6.2 Modo de comparación. ................................................... 96
4.6.3 Modo PWM. ................................................................... 97
4.7 Módulo de Tensión de Referencia......................................................... 100
4.8 Módulo Comparador Analógico. ........................................................... 102
4.9 Convertidor A/D. ................................................................................... 106
4.10 Módulos de comunicación serie. ......................................................... 112
4.10.1 Puerto Serie Síncrono (SSP)........................................... 112
4.10.1.1 Modo SPI. .................................................................... 115
4.10.1.2 Modo I2C. .................................................................... 117

Santiago Salamanca Miño II Escuela de Ingenierías Industriales


4.10.2 USART. .......................................................................... 125
4.10.2.1 Modo asíncrono. ................................... 128
4.10.2.2 Modo síncrono ...................................... 133
5 Programación con PIC. ............................................................................................ 137
5.1 Introducción. .......................................................................................... 137
5.2 Directivas del ensamblador MPASM. ................................................... 137
5.3 Creación de programas. ......................................................................... 156
5.3.1 Un solo código fuente (ensamblador)............................ 156
5.3.2 Varios códigos fuente (linkador). .................................. 157
5.3.3 Utilización de librerías................................................... 158
5.4 Estructuras básicas de programación..................................................... 160
5.4.1 Estructuras iterativas...................................................... 160
5.4.1.1 While............................................................ 160
5.4.1.2 Do while....................................................... 161
5.4.1.3 For................................................................ 161
5.4.2 Estructuras condicionales. ............................................. 162
5.4.2.1 If................................................................... 162
5.4.2.2 If ... else........................................................ 163
5.4.3 Códigos de condición..................................................... 164
5.4.3.1 Igual. ............................................................ 164
5.4.3.2 Distinto......................................................... 164
5.4.3.3 Mayor........................................................... 164
5.4.3.4 Mayor o igual............................................... 165
5.4.3.5 Menor........................................................... 165
5.4.3.6 Menor o igual............................................... 165
5.4.3.7 Condiciones más complejas......................... 165
5.5 Ejemplo de librerías: librería matemática.............................................. 166
5.5.1 Rutinas de coma flotante................................................ 166
5.5.1.1 Manejo de excepciones................................ 168
5.5.1.2 Redondeo. .................................................... 168
5.5.1.3 Conversión de entero a flotante. .................. 168

Santiago Salamanca Miño III Escuela de Ingenierías Industriales


5.5.1.4 Normalización.............................................. 168
5.5.1.5 Conversión de flotante a entero. .................. 169
5.5.1.6 Suma/Resta. ................................................. 169
5.5.1.7 Multiplicación.............................................. 169
5.5.1.8 División........................................................ 170
5.5.2 Rutinas en coma fija. ..................................................... 171
5.5.2.1 Multiplicación.............................................. 171
5.5.2.2 División........................................................ 172
5.5.3 Funciones matemáticas en coma flotante. ..................... 173
5.5.3.1 Función raíz cuadrada.................................. 174
5.5.3.2 Funciones exponenciales. ........................... 175
5.5.3.3 Funciones logarítmicas. ............................... 176
5.5.3.4 Funcione trigonométricas. ........................... 178
5.5.3.5 Función potencia.......................................... 179
5.5.3.6 Función parte entera por defecto. ................ 182
5.5.3.7 Comparación lógica en coma flotante. ........ 182
5.5.3.8 Generador aleatorio de números enteros. .... 183
5.5.4 Conversión de coma flotante a ASCII. .......................... 183
5.5.4.1 Conversión de coma flotante
a ASCII en base 10. ..................................... 184
5.5.4.2 Personalización de la rutina. ........................ 184
5.5.4.3 Resumen. ..................................................... 185

APÉNDICE A: Protocolo I2C........................................................................................ 187
A.1 Introducción ......................................................................................... 187
A.2 Inicialización y fin de transferencia de datos....................................... 187
A.3 Direccionamiento de dispositivos en I2C............................................. 188
A.4 Reconocimiento de transferencia......................................................... 189

Santiago Salamanca Miño IV Escuela de Ingenierías Industriales

Microcontroladores PIC de la Gama Media. 1. Introducción a los Microcontroladores

Capítulo 1. Introducción a los microcontroladores.

1.1 ¿Qué es un microcontrolador?

Hace unos años, los sistemas de control se implementaban usando exclusivamente lógica de
componentes, lo que hacía que fuesen dispositivos de gran tamaño y muy pesados. Para
facilitar una velocidad más alta y mejorar la eficiencia de estos dispositivos de control, se
trató de reducir su tamaño, apareciendo así los microprocesadores. Siguiendo con el proceso
de miniaturización, el siguiente paso consistió en la fabricación de un controlador que
integrase todos sus componentes en un sólo chip. A esto es a lo que se le conoce con el
nombre de microcontrolador, un computador dentro de un sólo chip.

Las principales características que diferencian a un microcontrolador de un microprocesador
son:
1. Son sistemas cerrados, ya que contiene todos los elementos de un computador en
un solo chip, frente a los microprocesadores que son sistemas abiertos, ya que
sacan las líneas de los buses de datos, direcciones y control al exterior, para la
conexión de memorias, interfaces de E/S, etc.
2. Son de propósito específico, es decir, son programados para realizar una única
tarea, mientras que los microprocesadores son de propósito general.

La historia de los microcontroladores surge desde dos vías de desarrollo paralelas; una desde
Intel y otra desde Texas Instruments. Los primeros microcontroladores son el 4004 y 4040 de
Intel que dieron lugar al 8048, a su vez predecesor del 8051. Aún así el primer
microcontrolador fue el TMS1000 de Texas Instruments. Éste integraba un reloj, procesador,
ROM, RAM, y soportes de E/S en un solo chip.

Santiago Salamanca Miño 1 Escuela de Ingenierías Industriales


Un microcontrolador, típicamente consta de:
-CPU o procesador.- Es el cerebro del sistema que procesa todos los datos que viajan a
lo largo del bus.
-Memorias.- Está formada por una no volátil (ROM, EEPROM, FLASH) donde se
almacenan los programas y una volátil (RAM) donde se almacenan los datos.
-Reloj principal.- Normalmente todos los microcontroladores tienen incorporados
circuitos osciladores para el funcionamiento de éstos.
-Puertos E/S (Entrada/Salida).- Soportan las líneas que comunican al microcontrolador
con los periféricos externos.
-Perro guardián o Watchdog.- Contador que resetea al microcontrolador cada vez que
rebosa. Sirve para evitar fallos de funcionamiento, por lo que hay que
inicializarlo periódicamente antes de que rebose.
-Protección ante fallo de alimentación o Browout.- Circuito que resetea al
microcontrolador cuando la tensión de alimentación baja de un cierto límite.
-Temporizadores.- Para controlar periodos de tiempo.
-Convertidores A/D y D/A. (Analógico/Digital y Digital/Analógico)
-Comparadores analógicos
-Moduladores de anchura de impulsos.
-Puertos de comunicación.- Tanto serie como paralelo.
-Control de interrupciones

Debido a que los microcontroladores sólo incluyen las características específicas para una
tarea, su coste es relativamente bajo. Un microcontrolador típico realiza funciones de
manipulación de instrucciones, posee E/S de accesos fáciles y directos, y un proceso de
interrupciones rápido y eficiente. Además también reducen de manera notable los costes de
diseño. Hay gran variedad de microcontroladores. Dependiendo de la potencia y
características que se necesiten, se pueden elegir microcontroladores de 4, 8, 16 ó 32 bits.
Además existen versiones especializadas que incluyen módulos especiales para
comunicaciones, teclados, procesamiento de señales, procesamiento de video, y otras tareas.



1.2 Aplicaciones

El mercado de los microcontroladores está creciendo cada año y parece no tener barreras. Los
microcontroladores a menudo se encuentran en aplicaciones domésticas ( microondas,
refrigeradores, televisión, equipos de música), ordenadores con sus componentes (impresoras,
módems, lectores de discos), coches (ingeniería de control, diagnostico, control de
climatización), control medioambiental (invernaderos, fabricas, casas), instrumentación,
aeronáutica, y miles de usos más. En muchos podemos encontrar más de un microcontrolador.

Los microcontroladores son muy usados en robótica, donde la comunicación entre
controladores es una gran ventaja. Esto hace posible muchas tareas específicas al distribuir un
gran número de microcontroladores por todo el sistema. La comunicación entre cada
microcontrolador y uno central permitiría procesar la información por un ordenador central, o
transmitirlo a otros microcontroladores del sistema.

Otro ejemplo de aplicación de los microcontroladores, es la de utilizarlos para monitorizar y
gravar parámetros medioambientales (temperatura, humedad, precipitaciones, etc.). Pequeño
tamaño, bajo consumo de potencia, y flexibilidad hacen de este dispositivo ideal para este tipo
de aplicaciones.

1.3 Los microcontroladores PIC (Microchip)

Los microcontroladores PIC fueron los primeros microcontroladores RISC, es decir,
microcontroladores con un juego de instrucciones reducido. El hecho de ser procesadores de
tipo RISC generalmente implica simplicidad en los diseños, permitiendo más características a
bajo coste.

Los principales beneficios de esta simplicidad en el diseño son que los microcontroladores se
implementan en chip muy pequeños, con pocos pines, y tienen un consumo de potencia muy
bajo.



Los microcontroladores PIC ganaron popularidad rápidamente. Aparecían con frecuencia en
revistas de ocio, y su uso era cada vez mayor en gran número de diseños. Debido a su bajo
costo, pequeño tamaño, y bajo consumo, estos microcontroladores pueden ahora ser usados en
áreas en las que previamente no habrían sido apropiados (tal como circuitos lógicos).

Las principales características de los PIC son:

-Arquitectura Harvard.- Consiste en la existencia de dos memorias independientes,
una de datos y otra de instrucciones, con sus respectivos buses. Esto permite el
acceso simultaneo al programa y los datos, y solapar algunas operaciones para
mejorar el proceso.
-Segmentación de instrucciones.- Consiste en dividir la ejecución de las
instrucciones en varias fases, en el caso concreto de los PIC dos fases, de
manera que se realizan simultáneamente distintas fases de distintas
instrucciones. Así cada instrucción se ejecuta en un ciclo de instrucción (4
ciclos de reloj), excepto las de salto que ocupan tantos ciclos de instrucción
como necesite para calcular la dirección de salto.
-Formato de instrucciones de longitud constante.- Permite optimizar la memoria de
instrucciones y el diseño de ensambladores y compiladores.
-RISC (computador de reducido juego de instrucciones)
-Instrucciones ortogonales.- Todas las instrucciones pueden manejar cualquier
elemento de la arquitectura como fuente o destino.
-Arquitectura basada en un banco de registros.- Todos los objetos del sistema se
encuentran implementados físicamente como registros.
-Gran variedad de microcontroladores y muchas herramientas de soporte.



1.4 Las gamas de los PIC

La forma de designación de los PIC en general obedece a la siguiente estructura:

PIC nn LLL xxx

Siendo :
nn – un número propio de la gama del PIC.
LLL – código de letras donde la primera indica la tensión de alimentación y las otras
dos el tipo de memoria que utiliza. En la tabla 1.1 se puede ver las distintas
opciones que se pueden dar.

TABLA 1.1 Nomenclatura de los PIC.
LETRAS ALIMENTACIÓN MEMORIA
C Standard (4.5-6.0 V) EPROM
CR Standard (4.5-6.0 V) ROM
F Standard (4.5-6.0 V) FLASH
LC Extendida (2.5-6.0 V) EPROM
LCR Extendida (2.5-6.0 V) ROM
LF Extendida (2.0-6.0 V) FLASH
xxx – número que indica el modelo.

Los PIC se clasifican en distintas gamas atendiendo a los recursos disponibles en cada uno de
ellos. Las gamas son:
a) Gama Enana (PIC12Cxxx): La principal característica es que son muy pequeños,
con encapsulados de 8 pines, y un juego de 33 instrucciones de 12 bits.
b) Gama Baja (PIC16C5xx): Los encapsulados son de 18, 20 ó 28 pines. Al igual
que en los anteriores el número de instrucciones es de 33 con un ancho de 12 bits.
La memoria de programa es de 512 palabras, 1K ó 2K, y la de datos está
comprendida entre 25 y 73 bytes. No permite interrupciones.



c) Gama Media (PIC16Cxxx): Es la gama más variada y completa de los PIC, con
encapsulados desde 18 a 68 pines. Tiene un conjunto de 35 instrucciones de 14
bits de ancho. Permite además características importantes que no soportaban los
anteriores como son:
- Interrupciones
- Pila de 8 niveles que permite anidamiento de subrutinas.
Esta familia a su vez se puede dividir en subfamilias en función de los recursos de
que se dispongan.
d) Gama Alta (PIC17Cxxx): Tienen unas características muy diferentes a las
anteriores, ya que son microcontroladores de arquitectura abierta, es decir, que
sacan sus buses al exterior.
El número de instrucciones es de 58 con una anchura de 16 bits. Tienen
instrucciones vectorizadas.
e) Gama Mejorada (PIC18Cxxx): Es la última gama que ha salido. Tiene memoria
de programa de hasta 1M palabras. La mayoría de las instrucciones son de 16 bits,
aunque las hay también de 32 bits. El número total de instrucciones es de 76.
Esta gama está diseñada para aplicaciones de control. Todos ellos tienen
convertidores A/D y, por ejemplo, están en fase de desarrollo algunos modelos que
tienen interface para el bus CAN.

1.5 Los PIC de la gama media.

A lo largo de este proyecto sólo se hablará de los PIC de la Gama Media, siendo esta la más
variada y completa. En la tabla 1.2 se muestran las características que definen a cada modelo
de los PIC de la Gama Media. Aparecen sólo los más significantes, ya que la variedad es muy
amplia.



TABLA 1.2 Principales características de los PIC de la Gama Media.
Reloj Memoria Periféricos Características

Memoria de programa

Cápsulas
Detector de fallo en VDD “Brown-out”
Máxima frecuencia de trabajo

Tensión interna de referencia
Módulos de temporización
EEPROM de datos (bytes)

Convertidor A/D de 8 bits

Rango de voltaje (voltios)
Memoria de datos (bytes)

Fuentes de interrupción
Puerto Paralelo

Comparadores

Patillas de E/S
Módulos CCP

Puertos serie

Pines PLCC

Pines QFP
Pines DIP
EEROM
EPROM

3,0-
PIC16C61 20 1K --- 36 --- TMR0 -- --- -- -- -- -- 3 13 --- 18 18 --
6,0
TMR0,TMR1 2,5-
PIC16C62 20 2K --- 128 --- 2 SPI/I2C/SCI -- -- -- -- 10 22 --- 28 28 --
,TMR2 6,0
TMR0,TMR1 3,0-
PIC16C63 20 4K --- 192 --- 2 SPI/I2C/SCI --- -- -- -- 10 22 --- 28 28 --
,TMR2 6,0
TMR0,TMR1 3,0-
PIC16C64 20 2K --- 128 --- 1 SPI/I2C Si -- -- -- 8 33 --- 40 44 44
,TMR2 6,0
TMR0,TMR1 3,0-
PIC16C65 20 4K --- 192 --- 2 SPI/I2C/SCI Si -- -- -- 11 33 --- 40 44 44
,TMR2 6,0
3,0-
PIC16C620 20 512 --- 80 --- TMR0 -- ---- -- -- 2 Si 4 13 Si 18 18 20
6,0
3,0-
PIC16C621 20 1K --- 80 --- TMR0 -- ---- -- -- 2 Si 4 13 Si 18 18 20
6,0
3,0-
PIC16C622 20 2K --- 128 --- TMR0 -- ---- -- -- 2 Si 4 13 Si 18 18 20
6,0
3,0-
PIC16C71 20 1K --- 36 --- TMR0 -- ---- -- 4ch -- -- 4 13 --- 18 18 --
6,0
TMR0,TMR1 3,0-
PIC16C73 20 4K --- 192 --- 2 SPI/I2C/SCI -- 5ch -- -- 11 22 --- 28 28 --
,TMR2 6,0
TMR0,TMR1 3,0-
PIC16C74 20 4K --- 192 --- 2 SPI/I2C/SCI Si 8ch -- -- 12 33 --- 40 44 44
,TMR2 6,0
TMR0,TMR1 2,5-
PIC16C76 20 8K --- 368 --- 2 SPI/I2C/SCI -- 5ch -- -- 11 22 Si 28 28 --
,TMR2 6,0
3,0-
PIC16C84 20 -- 1K 36 64 TMR0 -- ---- -- -- -- -- 4 13 --- 18 18 --
6,0

A continuación en la figura 1.1 se muestran algunos de los encapsulados utilizados en los PIC
de la Gama Media. Como ya se ha dicho anteriormente, éstos van desde los 18 a 68 pines.



Figura 1.1 Principales diagramas de patillas.

La descripción de las funciones de las distintas patillas del microcontrolador son:
RA0/AN0-RA2/AN2: Líneas de E/S digitales del Puerto A, o entradas analógicas.
RA3/AN3/VREF: E/S digital, analógica o entrada externa de VREF.
RA4/T0CKI: E/S digital o entrada de reloj externo para TMR0.
RA5/AN4/ SS : E/S digital, analógica o selección del puerto síncrono.
RB0/INT-RB7: E/S digitales del Puerto B. RB0/INT puede actuar como entrada de
interrupción externa. RB4-Rb7 pueden provocar una interrupción cuando cambian de
estado.
RC0/T1OSO/T1CKI: E/S digital del Puerto C. Conexión del oscilador externo para
el temporizador TMR1 o entrada de reloj para el TMR1.



RC1/T1OSI/CCP2: E/S digital. Conexión del oscilador externo para el TMR1 o
salida del módulo 2 de captura/comparación.
RC2/CCP1: E/S digital. Salida del módulo 1 de captura/comparación.
RC3/SCK/SCL: E/S digital. E/S de reloj para el Puerto Serie Síncrono (SSP) en los
módulos SPI o I2C.
RC4/SDI/SDA: E/S digital. Entrada de datos serie en el modo SPI. E/S de datos serie
en el modo I2C.
RC5/SDO: E/S digital. Salida de datos serie en el modo SPI.
RC6/TX/CK: E/S digital. Transmisión serie asíncrona. Entrada de reloj para
comunicación serie síncrona.
RC7/RX/DT: E/S digital. Recepción serie asíncrona. Línea de datos en la
comunicación serie síncrona.
RD0/PSP0-RD7/PSP7: E/S digitales del Puerto D. Este puerto puede trabajar como
puerto paralelo esclavo para interconexión con un bus de datos de 8 bits de otro
microprocesador.
RE0/ RD /AN5: E/S digital del Puerto E. Señal de lectura del puerto paralelo esclavo.
Entrada analógica.
RE1/ WR /AN6: E/S digital. Señal de escritura del puerto paralelo esclavo. Entrada
analógica.
RE2/ CS /AN7: E/S digital. Señal de activación del puerto paralelo esclavo. Entrada
analógica.


Microcontroladores PIC de la Gama Media. 2. La Arquitectura de los PIC de la Gama Media

Capítulo 2. La Arquitectura de los PIC de la Gama Media.

2.1 Introducción

Desde el punto de vista de la arquitectura, la característica más importante de los PIC es que
utilizan la Harvard, frente a la Von Neumann que es la habitual.

La arquitectura Harvard tiene la memoria de programa y la memoria de datos separadas y se
accede a ellas mediante buses distintos. Esto mejora el ancho de banda sobre la tradicional
arquitectura secuencial, en la cual los programas y datos son buscados en la misma memoria,
utilizando el mismo bus. En la arquitectura Harvard mientras se accede a la memoria de
programa, sobre la memoria de datos se puede estar leyendo o escribiendo, lo que permite
ejecutar una instrucción a la vez que se busca la siguiente.

En la figura 2.1 se muestra el esquema de la arquitectura general de los PIC de la Gama
Media.

Además de las características antes mencionadas, otras características que poseen los PIC de
la Gama Media son:
a) Memoria no volátil de programa de hasta 8K x 14 de tamaño, direccionada por el
contador de programa (PC) de 13 bits.
b) Memoria RAM de datos de hasta 368 x 8 de tamaño, direccionada por el código de
operación o por el registro FSR y parte del registro STATUS.
c) Unidad aritmético-lógica de 8 bits con un registro acumulador de trabajo asociado
también de 8 bits. Realiza operaciones aritméticas y lógicas utilizando siempre
como operando el registro acumulador y otro dato perteneciente a cualquier
registro. Realiza operaciones de suma, resta y desplazamiento. Opera en
complemento a 2 (C’2). Dependiendo del resultado, afecta a algunos bits del
registro de estado.



Figura 2.1 Diagrama de bloques general de los PIC de la gama media.
Nota 1: Los bits de mayor orden en el direccionamiento directo de la RAM se obtienen del Registro de Estado.
2: No todos los dispositivos tienen estas características, habrá que consultar las hojas de características.
3: Muchos de los pines de las puertas E/S de propósito general están multiplexadas con una o más
funciones de los módulos periféricos. La combinación de las funciones multiplexadas dependen del
dispositivo.



d) Oscilador encargado de las generaciones de tiempo del sistema.
e) Circuitos controladores del RESET.
f) Puertos E/S. Existen hasta 7 puertos de E/S, aunque no existe ningún dispositivo
que los implemente todos. Además se multiplexan con distintos elementos del
sistema.
g) Módulos periféricos. Son la característica que diferencia a los distintos
microcontroladores. Éstos facilitan la comunicación con el mundo exterior, tal
como las E/S de propósito general, y tareas internas tal como puede ser la
generación de las distintas bases de tiempo. Los periféricos sobre los que se está
hablando son; E/S de propósito general, hasta tres temporizadores, módulo de
captura, comparación, y PWM (CCP), puerto serie síncrono (SSP), USART (SCI),
módulo para generación de voltajes de referencia, módulos comparadores
analógicos, conversores analógico digital (A/D), módulo para control de Display
de cristal líquido (LCD) y puerto paralelo esclavo (PSP).
h) Registros generales del sistema.

2.2 Organización de la memoria.

La memoria de los PIC está dividida en dos bloques; la memoria de programa y la memoria
de datos. Cada uno de los bloques tiene su propio bus, pudiendo tener acceso a ambos bloques
de memoria en el mismo ciclo de reloj.

2.2.1 Organización de la memoria de programa.

En los PIC de la gama media el contador de programa es de 13 bits, con lo que se puede
direccionar una capacidad de memoria de 8K x 14 bits. El ancho de la memoria de programa
va a ser la longitud de una instrucción que es de 14 bits, por lo se podrán almacenar hasta 8K
instrucciones. De esta forma es fácil determinar si el dispositivo tiene suficiente memoria de
programa para una aplicación deseada.



Esta memoria de programa a su vez está dividida en cuatro páginas de 2K palabras cada una
(0h – 7FFh, 800h – FFFh, 1000h – 17FFh, y 1800h – 1FFFh). En la figura 2.2 se muestra el
mapa de memoria con la pila de 8 niveles. No todos los dispositivos tienen implementados
estos cuatro bancos.

Figura 2.2 Organización de la memoria de programa y la pila.

Para realizar los saltos entre las páginas de la memoria de programa se utilizan los dos bits
más altos del contador de programa (PC <11:12>), los cuales son implementados físicamente
en la memoria de datos en el registro PCLATCH <4:3>. Si el programa se ejecuta
secuencialmente no es necesario modificarlo.

Dentro de la memoria de programa existen dos direcciones reservadas:
1. Vector de Reset .- En un dispositivo, un reset pone el contador de programa (PC)
a cero. A esta dirección se la denomina “Dirección del Vector de Reset”, donde



está la dirección de inicio para la ejecución del programa. Cualquier reset borrará
también el contenido del registro PCLATH, de modo que cuando se produzca un
reset la dirección inicial a de estar localizada en la página 0 de la memoria de
programa.
2. Vector de Interrupción .- Cuando una interrupción es reconocida el PC es
forzado a la dirección 0004h. A esto es a lo que se le llama “Dirección del Vector
de Interrupción”. Cuando el PC es forzado con la dirección del vector de
interrupción, el PCLATH no es modificado. Por eso mismo en la dirección del
vector de interrupción, el registro PCLATH debería ser escrito con el valor que
especificará la localización deseada en la memoria de programa. Antes de realizar
esta operación, el PCLATH debería ser salvado para volverlo a restaurar al
terminar el tratamiento de la rutina de interrupción.

El contador de programa (PC) es un registro que especifica la dirección de la instrucción que
ha de ser ejecutada. El PC tiene un ancho de 13 bits, correspondiendo el byte más bajo con el
registro de lectura-escritura PCL, implementado en la memoria de datos, y el byte más alto
con el registro PCH. Este último contiene sólo los bits <12:8> del PC y no se puede leer ni
escribir directamente, sino que son cargados a través del PCLATH.

Existen varias instrucciones que modifican el flujo normal del sistema, y por tanto afectan al
PC. Estas instrucciones son:

1. Instrucciones de salto relativo: Son aquellas instrucciones que usan como
operando destino al PC. En estas instrucciones se cargan los 8 bits menos
significativos desde la UAL. El resto de los bits que coinciden con los del
PCLATH, habría que modificarlos manualmente.

2. Instrucción GOTO de salto incondicional: Carga desde el código de operación
los 11 bits menos significativos. Los dos que quedan se cargan desde el PCLATH
<4:3>. Si se hace un GOTO a una dirección que está en una página distinta,
primero hay que modificar estos bits del PCLATH.



3. Instrucción CALL de salto a subrutina: Es igual que la anterior con la diferencia
de que antes de modificar el PC, el valor que tuviese se lleva a la pila.
4. Instrucciones RETURN, RETLW y RETFIE de retornos de subrutinas y rutinas
de tratamiento de interrupción: Cargan directamente en el PC el valor que se halla
guardado anteriormente en la pila. No es necesario modificar el PCLATH.

Los PIC de la Gama Media poseen una pila de 8 niveles con un ancho de 13 bits, la cual nos
permite guardar las direcciones de retorno a un programa, cuando en éste se produce un salto
a una subrutina. Esto nos da capacidad para anidar hasta 8 subrutinas producidas por
programa o mediante interrupciones. Si en la pila ya se han almacenado 8 valores, el nuevo
valor se cargará sobre el primer nivel de la pila, de modo que puede dar problemas en el
funcionamiento de un programa.

2.2.2 Organización de la memoria de datos.

La memoria de datos (figura 2.3) está dividida en dos partes:
a) Memoria de registros especiales (FSR Memory): Está formada por aquellos
registros que son usados por la CPU y los periféricos para controlar una operación.
b) Memoria de propósito general: Está formada por la memoria que puede usar el
programador.

En ambos casos, está dividida hasta en 4 bancos de memoria de hasta 128 bytes, aunque
muchos de los modelos no traen implementados estos dos últimos bancos. En algunos
modelos de PIC la memoria de propósito general, está sólo implementado físicamente en el
banco0, estando el resto de los bancos mapeados en éste.



Figura 2.3 Organización de la memoria de datos.
Nota 1: Los registros en negrita están presentes en todos los dispositivos.
2: Puede que no todas las posiciones estén implementadas. Las localizaciones no implementadas se
leen como ‘0’.



El modo de acceso a cada uno de los bancos dependerá del tipo de direccionamiento que se
use.

Estos tipos de direccionamiento son:
1. Direccionamiento directo: La dirección final se obtiene con:
a. Los bits RP1-RP0 del registro de estado (STATUS), los cuales seleccionan
el banco de memoria.
b. Los 7 bits del código de operación, los cuales indican la posición del dato
dentro del banco.
2. Direccionamiento indirecto: Con este tipo de direccionamiento lo que se da es la
dirección donde se encuentra la dirección del dato. Para ello se usa el registro
INDF. Al usar este registro (que no está implementado físicamente), lo que se hace
es acceder al registro de datos FSR de 8 bits. Los 7 bits con menos peso del FSR
seleccionan la posición dentro del banco, y el bit de mayor peso junto con el bit
IRP del registro de estado, seleccionan el banco.

Un programa que borra una zona de memoria puede ser un ejemplo de aplicación
de direccionamiento indirecto. El programa sería como el siguiente:

BCF STATUS,IRP ; Selección del banco 0 de memoria.
MOVLW 0X20 ; Mueve el valor 20h al registro W
MOVWF FSR ; Carga valor de W en FSR
SIGUIENTE CLRF INDF ; Borra la posición de memoria que marca FSR
INCF FSR,1 ; Incrementa valor del FSR
BTFSS FSR,4 ; Test del bit 4 del FSR, si es 1, no ejecuta la
; siguiente instrucción y salta.
GOTO SIGUIENTE ; Vuelve a SIGUIENTE.
…
…
Este programa ejemplo borraría la memoria de datos desde la posición h’20’ hasta
h’2F’.



2.2.3 Registros y recursos comunes.

2.2.3.1 Registro de Estado.

Es un registro formado por 8 bits, que contiene el estado de la UAL, del RESET y selecciona
el banco de la memoria de datos sobre la que queremos trabajar.. Por esta última causa, el
registro de estado se encuentra en todos los bancos, y en la misma posición.

R/W-0 R/W-0 R/W-0 R-1 R-1 R/W-x R/W-x R/W-x
IRP RP1 RP0 TO PD Z DC C
bit7 bit0
A continuación se muestra la función de cada bit del registro de estado.
bit 7 IRP: Selección de bancos para el direccionamiento indirecto.
1 = Banco 2,3 (100h – 1FFh)
0 = Banco 0,1 (00h – FFh)
bit 6:5 RP1:RP0: Selección del banco de la memoria de datos para el
direccionamiento directo.
11 = Banco 3 (180h – 1FFh)
10 = Banco 2 (100h – 17Fh)
01 = Banco 1 (80h – FFh)
00 = Banco 0 (00h – 7Fh)
bit 4 TO : Timer Out.
1 = Tras conectar Vdd o ejecutar “CLRWDT” o “SLEEP”.
0 = Al rebasar el WDT
bit 3 PD : Power Down
1 = Tras conectar Vdd o ejecutar “CLRWDT”.
0 = Al ejecutar la instrucción “SLEEP".
bit 2 Z: Bit de cero.
1 = El resultado de una operación es 0.
0 = El resultado es distinto de 0.
bit 1 DC: Acarreo en el 4º bit de menos peso.
1 = Acarreo en la suma y no en la resta.
bit 0 C: Acarreo en el 8º bit.
Estos dos últimos bits, en la suma representan lo que se conoce comúnmente con acarreo, sin
embargo en la resta realizan la función de bit de signo (bit de Borrow ), indicando que el
resultado es negativo si Borrow es 0, y mayor o igual a 0 si es 1.



2.2.3.2 Registro de Opciones.

El registro de opciones es un registro de lectura-escritura, que contiene los bits de
configuración del divisor de frecuencia del TMR0/WDT, de las interrupciones externas, del
TMR0, y la configuración de las Puerta B con cargas Pull-Up.

R/W-1 R/W-1 R/W-1 R/W-1 R/W-1 R/W-1 R/W-1 R/W-1
RBPU INTEDG T0CS T0SE PSA PS2 PS1 PS0
bit7 bit0
bit 7 RBPU : Conexión de cargas Pull-Up para la Puerta B.
1 = Todas las cargas Pull-Up desconectadas.
0 = Todas las cargas Pull-Up conectadas.
bit 6 INTEDG: Tipo de flanco para la interrupción.
1 = RB0/INT sensible a flanco ascendente.
0 = RB0/INT sensible a flanco descendente.
bit 5 T0CS: Fuente de reloj para el TMR0.
1 = Pulsos introducidos por T0CKI (contador).
0 = Pulsos de reloj interno Fosc/4 (temporizador).
bit 4 T0SE: Tipo de flanco activo del T0CKI.
1 = Incremento del TMR0 cada flanco descendente.
0 = Incremento del TMR0 cada flanco ascendente.
bit 3 PSA: Asignación del divisor de frecuencia.
1 = Se le asigna al WDT.
0 = Se le asigna al TMR0.
bit 2-0 PS2:PS0: Valor del divisor de frecuencia.

Valor División del TMR0 División del WDT
000 1:2 1:1
001 1:4 1:2
010 1:8 1:4
011 1:16 1:8
100 1:32 1:16
101 1:64 1:32
110 1:128 1:64
111 1:256 1:128

Para conseguir asignar 1:1 al divisor de frecuencia en el TMR0, se le asigna el
divisor al WDT.



2.2.3.3 Palabra de configuración.

La Palabra de Configuración está formada por 14 bits. Se utiliza para la selección de distintos
aspectos de la configuración del dispositivo según las necesidades de la aplicación. Su
localización en la memoria de programa es la 2007h. Esta posición no es accesible durante el
modo de funcionamiento normal, por lo que estos registros deberán ser configurados en la
fase de programación.

CP1 CP0 CP1 CP0 CP1 CP0 - BODEN CP1 CP0 PWRTE WDTE FOSC1 FOSC0
bit13 bit0

bit 13-8 CP<1:0>: Bits de protección de código.
5-4:
512 1k 2k
11 Off Off Off
10 Off Off ½ alta On
01 Off ½ alta On ¾ alta On
00 On On On
bit 7 No implementado: Su lectura es 1.
bit 6 BODEN: Detección del “Brown-Out” (Fallo de alimentación)
1 = detección activada.
0 = Detección desactivada.
bit 3 PWRTE : Activación del temporizador “Power-Up”
1 = Desactivado.
0 = Activado.
bit 2 WDTE: Activación del “Watchdog” (perro guardián)
1 = Activado
0 = Desactivado.
bit 1-0 FOSC1-FOSC0: Selección del tipo de oscilador.
11 = Oscilador RC.
10 = Oscilador HS
01 = Oscilador XT
00 = Oscilador LP



2.3 Oscilador.

El circuito de oscilación se utiliza para generar las señales de reloj en el sistema necesarias
para la ejecución de instrucciones y para el funcionamiento de los periféricos.

Existen hasta ocho tipos de osciladores. Los distintos tipos permiten mayor flexibilidad del
dispositivo según las necesidades, así los hay de muy bajo coste, como las redes RC, y otros
de bajo consumo como son los cristales de cuarzo del modo LP.

La configuración de un oscilador u otro se realiza mediante los bits FOSC2, FOSC1 Y
FOSC0 de la palabra de configuración. No todos los modelos poseen la posibilidad de
configurar cualquier tipo de oscilador, en estos casos sólo tienen los bit FOSC1 Y FOSC0 en
la palabra de configuración. Los valores de estos bits para la configuración de los distintos
osciladores son los que se pueden ver en las tablas 2.1 y 2.2.

TABLA 2.1 Selección del modo de oscilación con FOSC1:FOSC0.
Bits de
Modo Ganancia de los
configuración Comentarios
OSC inversores internos
FOSC1:FOSC0
Solución más barata (sólo requiere una resistencia y
un condensador). Máxima variación del tiempo
11 RC −
base.
Modo del dispositivo por defecto
Cristal de cuarzo para aplicaciones de alta
10 HS Ganancia alta frecuencia. Es el modo que más potencia consume
de los tres cristales.
Cristal de cuarzo para un rango de frecuencias
01 XT Ganancia media
estándar.
Cristal de cuarzo para aplicaciones de baja
00 LP Ganancia baja frecuencia. Es el modo que menos potencia
consume de los tres cristales.



TABLA 2.2 Selección del modo de oscilación con FOSC2:FOSC0.
Ganancia de
Bits de
Modo los
configuración Comentarios
OSC inversores
FOSC2:FOSC0
internos
Red RC externa sacando la señal de oscilación por la
EXTRC con
111 − patilla CLKOUT. Solución barata. Máxima variación
CLKOUT
en el tiempo base. Modo del dispositivo por defecto
Red RC externa. Barata solución. Máxima variación
110 EXTRC − en el tiempo base. La señal de oscilación no sale al
exterior.
Red RC interna sacando la señal de oscilación por la
INTRC con
101 − patilla CLKOUT. Es la solución más barata.
CLKOUT
Oscilador de 4MHz.
Red RC interna. La señal de oscilación no sale al
100 INTRC −
exterior. Solución más barata. Oscilador de 4MHz.
011 − − Reservado
Cristal de cuarzo para aplicaciones de alta frecuencia.
10 HS Ganancia alta Es el modo que más potencia consume de los tres
cristales.
Ganancia Cristal de cuarzo para un rango de frecuencias
01 XT
media estándar.
Cristal de cuarzo para aplicaciones de baja frecuencia.
Ganancia
00 LP Es el modo que menos potencia consume de los tres
baja
cristales.

La diferencia entre los tres últimos viene dada por la ganancia de los inversores internos, que
son los que modifican la frecuencia. En general siempre se opta por la opción con menor
ganancia posible que cumpla las especificaciones. Esto implicará menores corrientes y con
ello menor consumo de potencia.

En la figura 2.4 se ve el modo de conexión para resonadores de cristal o de cuarzo. En este
caso se conectan a las patillas OSC1 y OSC2, usando esta última como realimentación.



Figura 2.4 Operación de osciladores en los modos HS, XT o LP.
Nota 1: La resistencia en serie, RS, es necesaria para cristales de alta tecnología.
2: La resistencia de realimentación, RF, varía entre 2 y 10 MΩ.
3: Dependiendo del dispositivo, el buffer de la lógica interna puede estar tanto antes
como después del inversor.

Para una red RC el modo de conexión utilizará únicamente la patilla OSC1. La frecuencia de
oscilación dependerá de VDD, REXT y de CEXT (figura 2.5). El fabricante recomienda que REXT
tenga un valor de entre 3KΩ y 100KΩ y que CEXT sea mayor de 20pF. Además la frecuencia
del oscilador/4 se obtiene a través de la patilla OSC2, en caso de que esté configurada en los
modos EXTRC o INTRC con CLKOUT, se puede usar para sincronización de otras lógicas.

Figura 2.5 Operación en modo RC.
Nota 1: Esta patilla también puede ser configurada como una E/S de propósito general.



Como un dispositivo incrementa su voltaje de alimentación desde 0 hasta VDD, el oscilador
tardará un tiempo en funcionar correctamente. Este tiempo de comienzo o Start-Up depende
de muchos factores:
a) Para los osciladores RC depende del valor de la resistencia y condensador usado,
tiempo de subida de VDD, y temperatura del sistema.
b) Para los osciladores de cristales los factores que intervienen son la frecuencia del
cristal, los valores de la resistencia en serie, RS y de los condensadores C1 y C2, el
tiempo de subida de VDD, la temperatura del sistema, la selección del modo de
oscilador, la composición del circuito oscilador, y el ruido del sistema.

En la figura 2.6 se muestra un ejemplo de Start–Up. Se puede ver que la señal de oscilación
está centrada en VDD/2, siendo el valor pico a pico durante el arranque del oscilador bastante
bajo (menos del 50% de VDD).

Figura 2.6 Característica Start-Up de un oscilador.

Siempre que se quiera grabar un PIC es necesario consultar las hojas de características para la
configuración del oscilador.



2.4 Reset

La función del reset es la de dejar al sistema en un estado conocido. Existen varias fuentes de
RESET:
a) Power On Reset (POR).
b) Activación de MCLR durante funcionamiento normal.
c) Activación de MCLR en el modo de reposo
d) Desbordamiento del WDT durante funcionamiento normal.
e) Reset de Brown-Out (BOR).
f) Reset por error de paridad (PER).

La figura 2.7 se muestra un bloque simplificado de la lógica que gobierna el reset del sistema,
para un caso general.

En esta figura se puede ver una zona denominada OST/PWRT, que consiste en:
a) Power-up Timer (PWRT): Es un temporizador que proporciona un retardo de
72ms a partir de un reset de tipo POR o BOR, de tal forma que el PIC se mantiene
reseteado durante este tiempo, así al finalizar la temporización la tensión de
alimentación tendrá un valor aceptable. Este temporizador se habilita mediante el
bit PWRT de la palabra de configuración. Para generar este retardo existe un
circuito interno RC dedicado.
b) Oscillator Start-Up Timer (OST): Este oscilador proporciona un retardo de
1024 veces el periodo de oscilación (desde OSC1) después del retardo PWRT. De
esta forma se asegura que el oscilador cristal o cerámico es estable cuando el PIC
empieza a funcionar. Este retardo sólo funciona cuando el PIC se ha configurado
para usar un oscilador XT, HS o LP y el reset es tipo POR, BOR o de wake-up
desde el modo de reposo (sleep).



Figura 2.7 Lógica que gobierna el Reset de un sistema.
Nota 1: Este es un oscilador distinto al oscilador del pin CLKIN o al oscilador interno INTRC.
2: Las características que están encerrados en cuadros no están disponibles en todos los modelos,
ver hoja de características del dispositivo.
3: En algunos modelos, este pin puede estar configurado como entrada de propósito general.
4: En los primeros microcontroladores PIC tenían la configuración de modo que para PWRTE =1
estuviera habilitado, mientras que el resto de los modelos, la configuración estaba definida
para PWRTE =0.

A continuación (tabla 2.3) se muestran los distintos retardos para las posibles situaciones en
las que se puede ver el sistema.

TABLA 2.3 Retardos típicos según las situaciones.
CONFIGURACIÓN TIEMPO DE POWER-UP BROWN-OUT WAKE-UP
DEL OSCILADOR RESET DESDE SLEEP
Habilitado Deshabilitado
XT, HS, LP 72 ms + 1024TOSC 1024TOSC 72 ms + 1024TOSC 1024TOSC
RC 72 ms ⎯ (1)
72 ms ⎯(1)
Nota 1: Dispositivos con oscilador Interno/Externo RC tienen un retardo de 250µs.



El Power-on Reset consiste en la activación del reset cuando se detecta la conexión de la
alimentación al dispositivo. Dos topologías para el circuito de POR se pueden ver en la figura
2.8, siendo la primera para el caso general y la segunda para el caso en que VDD crezca de
forma lenta.

Nota 1: La resistencia es opcional.

Figura 2.8 Topologías para el circuito de POR.
En el segundo caso el diodo ayuda a la descarga del condensador cuando VDD disminuye su
valor.

Las siguientes figuras (2.9 – 2.12) muestran el comportamiento temporal de las señales según
el caso.

Figura 2.9 Secuencia de Time-out en subida de alimentación. MCLR conectado a VDD.



Figura 2.10 Secuencia de Time-out en subida de alimentación. MCLR no conectado a VDD.
(Caso1).

Figura 2.11 Secuencia de Time-out en subida de alimentación. MCLR no conectado a VDD.
(Caso2).

Figura 2.12 Secuencia de Time-out en subida de alimentación. MCLR conectado a VDD
(tiempo de subida lento).



El Brown-out Reset consiste en producir un reset en el sistema cuando la tensión de
alimentación VDD cae por debajo de un determinado valor, específico para cada PIC. Los que
tengan implementados el BOR, tienen un parámetro (35), que es el tiempo mínimo que debe
estar VDD por debajo de la tensión de reset, para que éste se produzca. Esto asegura que el
elemento no continua la ejecución del programa fuera de los rangos válidos de operación.

Este tipo de reset se puede habilitar con el bit BODEN de la Palabra de Configuración. Una
vez que el nivel de la alimentación se restablezca, hay un retardo de 72ms en desactivarse el
reset interno.

Algunas de las situaciones de Brown-Out Reset se muestran en la figura 2.13.

Figura 2.13 Situaciones de Brown-out Reset.

Posibles circuitos usados para un BOR, cuando el circuito no tiene internamente el detector
implementado, o cuando la tensión que venga configurada no nos interesa, se muestran en las
figuras 2.14 y 2.15.



Figura 2.14 Circuito externo 1 de Brown-out.
Este circuito activará el reset cuando VDD esté por debajo de (Vz + 0.7V), donde Vz
es el voltaje Zener del diodo.
Nota 1: El circuito de Brown-out Reset interno debe de estar deshabilitado
cuando se use esta configuración.
2: Los valores de las resistencias dependen de las características del
transistor.

Figura 2.15 Circuito externo 2 de Brown-out.
Nota 1: Este circuito de BOR es más barato, pero menos exacto. El transistor Q1 se
corta cuando VDD baja de cierto nivel tal como:
R1
VDD • = 0.7V
R1 + R2
2: El circuito de Brown-out Reset interno debe de estar deshabilitado cuando
se use esta configuración.
3: Los valores de las resistencias dependen de las características del
transistor.



Debido a que existen distintas fuentes de reset, es necesario en determinadas ocasiones, saber
que tipo de reset se ha producido. Esto se hace consultando los bits POR y BOR del registro
PCON, y PD del Registro de Estado (tabla 2.4). La tabla 2.5 muestra la forma en que afecta
el Reset a los distintos registros.

TABLA 2.4 Bits de estado y su significado.
POR BOR TO PD Tipo de Reset
0 x 1 1 Power-On Reset.
0 x 0 x Incorrecto, TO está a 1 en POR .
0 x x 0 Incorrecto, PD está a 1 en POR .
1 0 1 1 Brown-Out Reset.
1 1 0 1 WDT Reset.
1 1 0 0 WDT Wake-Up.
1 1 u u MCLR reset en funcionamiento normal.
1 1 1 0 MCLR reset durante SLEEP.
Legenda: u: valor anterior. x: desconocido.

TABLA 2.5 Condiciones de inicialización de los registros especiales.
MCLR durante: Wake-up desde SLEEP
Power-On Reset -funcionamiento normal mediante:
Registro
Brown-Out Reset -SLEEP -Interrupciones
WDT Reset -Temporizador del WDT
ADCAPL 0000 0000 0000 0000 uuuu uuuu
ADCAPH 0000 0000 0000 0000 uuuu uuuu
ADCON0 0000 00-0 0000 00-0 uuuu uu-u
ADCON ---- -000 ---- -000 ---- -uuu
ADRES xxxx xxxx uuuu uuuu uuuu uuuu
ADTMRL 0000 0000 0000 0000 uuuu uuuu
ADMRH 0000 0000 0000 0000 uuuu uuuu
CCP1CON --00 0000 --00 0000 --uu uuuu
CCP2CON 0000 0000 0000 0000 uuuu uuuu
CCPR1L xxxx xxxx uuuu uuuu uuuu uuuu
CCPR1H xxxx xxxx uuuu uuuu uuuu uuuu
CCPR2L xxxx xxxx uuuu uuuu uuuu uuuu
CCPR2H xxxx xxxx uuuu uuuu uuuu uuuu
CMCON 00-- 0000 00—0000 uu-- uuuu
EEADR xxxx xxxx uuuu uuuu uuuu uuuu
EECON1 ---0 x000 ---0 q000 ---0 uuuu
EECON2 - - -
EEDATA xxxx xxxx uuuu uuuu uuuu uuuu
FSR xxxx xxxx uuuu uuuu uuuu uuuu
GPIO --xx xxxx --uu uuuu --uu uuuu
I2CADD 0000 0000 0000 0000 uuuu uuuu
I2CBUF xxxx xxxx uuuu uuuu uuuu uuuu
I2CCON 0000 0000 0000 0000 uuuu uuuu
I2CSTAT --00 0000 --00 0000 --uu uuuu
INDF - - -
INTCON 0000 000x 0000 000u uuuu uuuu
LCDCON 00-0 0000 00-0 0000 uu-u uuuu



MCLR durante: Wake-up desde SLEEP
Power-On Reset -funcionamiento normal mediante:
Registro
Brown-Out Reset -SLEEP -Interrupciones
WDT Reset -Temporizador del WDT
LCDD00 a LCDD15 xxxx xxxx uuuu uuuu uuuu uuuu
LCDPS ---- 0000 ---- 0000 ----uuuu
LCDPS 1111 1111 1111 1111 uuuu uuuu
OPTION_REG 1111 1111 1111 1111 uuuu uuuu
OSCCAL 0111 00-- uuuu uu-- uuuu uu--
PCL 0000 0000 0000 0000 PC+1(2)
PCLATH ---0 0000 ---0 0000 ---u uuuu
PCON ---- --0u ---- --uu ---- --uu
PIE1 0000 0000 0000 0000 uuuu uuuu
PIE2 ---- ---0 ---- ---0 ---- ---u
PIR1 0000 0000 0000 0000 uuuu uuuu
PIR2 ---- ---0 ---- ---0 ---- ---u
PORTA --xx xxxx --uu uuuu --uu uuuu
PORTB xxxx xxxx uuuu uuuu uuuu uuuu
PORTC xxxx xxxx uuuu uuuu uuuu uuuu
PORTD xxxx xxxx uuuu uuuu uuuu uuuu
PORTE ---- -xxx ---- -uuu ---- -uuu
POTF 0000 0000 0000 0000 uuuu uuuu
PORTG 0000 0000 0000 0000 uuuu uuuu
PR2 1111 1111 1111 1111 1111 1111
PREFA 0000 0000 0000 0000 uuuu uuuu
PREFB 0000 0000 0000 0000 uuuu uuuu
RCSTA 0000 --00x 0000 --00x uuuu –uuu
RCREG 0000 0000 0000 0000 uuuu uuuu
SLPCON 0011 1111 0011 1111 uuuu uuuu
SPBRG 0000 0000 0000 0000 uuuu uuuu
SSPBUF xxxx xxxx uuuu uuuu uuuu uuuu
SSPCON 0000 0000 0000 0000 uuuu uuuu
SSPADD 0000 0000 0000 0000 uuuu uuuu
SSPSTAT 0000 0000 0000 0000 uuuu uuuu
STATUS 0001 1xxx 000q quuu uuuq quuu
T1CON --00 0000 --uu uuuu --uu uuuu
T2CON -000 0000 -000 0000 -uuu uuuu
TMR0 xxxx xxxx uuuu uuuu uuuu uuuu
TMR1L xxxx xxxx uuuu uuuu uuuu uuuu
TMR1H xxxx xxxx uuuu uuuu uuuu uuuu
TMR2 0000 0000 0000 0000 uuuu uuuu
TRIS --11 1111 --11 1111 --uu uuuu
TRISA --11 1111 --11 1111 --uu uuuu
TRISB 1111 1111 1111 1111 uuuu uuuu
TRISC 1111 1111 1111 1111 uuuu uuuu
TRISE 0000 –111 0000 –111 uuuu –uuu
TRISF 1111 1111 1111 1111 uuuu uuuu
TRISG 1111 1111 1111 1111 uuuu uuuu
TXREG 0000 0000 0000 0000 uuuu uuuu
TXSTA 0000 –010 0000 –010 uuuu –uuu
VRCON 000- 0000 000- 0000 uuu- uuuu
W xxxx xxxx uuuu uuuu uuuu uuuu
Legenda: u = valor anterior x = desconocido – = no implementado q = depende de las condiciones



2.5 Temporizador y Perro Guardián.

En este apartado se tratará el funcionamiento del TMR0 en conjunción con el Perro Guardián
o Watchdog.
El TMR0 en su forma general tiene las siguientes características:
a) Contador/Temporizador de 8 bits.
b) Permite su lectura y escritura.
c) La fuente de reloj se puede seleccionar, pudiendo ser externa (contador) o interna
(temporizador).
d) La fuente externa puede ser seleccionada para que actúe cuando aparezca un flanco
de bajada o un flanco de subida.
e) Se puede seleccionar que se produzca una interrupción cuando haya rebose, es
decir, pase de FFh a 00h.
f) Se le puede asignar un divisor de frecuencia de 8 bits programable.

Por otro lado el perro guardián o Watchdog (WDT) es un temporizador con un oscilador RC,
que no requiere ningún elemento externo, funcionando incluso cuando el oscilador principal
del sistema no lo hace (modo de reposo).
La habilitación del perro guardián se realiza con el bit WDTE de la palabra de configuración.
Si el WDT está funcionando, cuando éste rebose se producirá un reset del PIC. En caso de que
el PIC en el momento del rebose del WDT se encuentre en modo de reposo, lo que se
producirá es el “despertar” de éste, continuando la ejecución del programa.
El periodo nominal del WDT es de 18 ms, que puede variar en función de la temperatura,
VDD, etc. (habrá que ver las características eléctricas). Además si se quieren tiempos mayores
se le puede asignar el divisor de frecuencia que lo puede aumentar hasta 1:128.

Este divisor de frecuencia es el mismo que funcionará con el TMR0, con lo cual, o actúa
sobre el TMR0 o sobre el WDT, pero nunca puede hacerlo sobre los dos a la vez.



La forma de programar el divisor es con el registro de opciones:

Valor División del TMR0 División del WDT
000 1:2 1:1
001 1:4 1:2
010 1:8 1:4
011 1:16 1:8
100 1:32 1:16
101 1:64 1:32
110 1:128 1:64
111 1:256 1:128

Para conseguir asignar 1:1 al divisor de frecuencia en el TMR0, se le asigna el
divisor al WDT.

En la figura 2.16 se puede ver el diagrama de bloques del funcionamiento del WDT y el
TMR0, con el divisor de frecuencias.

Figura 2.16 Diagrama de bloques del TMR0/WDT con el predivisor.



Como se puede ver, para el TMR0, el divisor de frecuencia actúa como un prescaler, es decir,
primero divide la fuente de reloj y luego esta fuente dividida actúa sobre el TMR0. Para el
WDT, sin embargo, es al revés, primero cuenta y luego actúa sobre la señal, es decir, lo hace
como postscaler.

Cuando tenemos habilitado el perro guardián, para que el sistema no se resetee, se ha de
inicializar periódicamente el WDT. Esto se consigue con las instrucciones CLRWDT o
SLEEP. Además se recomienda por parte del fabricante, que antes de modificar el postscaler
se debe ejecutar la instrucción CLRWDT, ya que si no, se puede producir el reset del PIC.

2.6 Puertas E/S.

Las puertas de E/S digital son el periférico más simple de todos los que aparecen en los PIC y
nos servirán para leer o escribir valores digitales desde o hacia el exterior. En algunos puertos
estos pines están multiplexados con otras funciones alternativas (convertidores A/D, E/S
serie, etc.). En el caso que lo tengamos para esa función, el pin no podrá funcionar como E/S
digital.

Los pines de las puertas E/S pueden ser seleccionados de forma individual para que actúen
como pines de entrada o de salida, a través de los registros TRIS, de tal forma que si
TRISX<n> es:
0 => Pin n de la puerta X actúa como salida.
1 => Pin n de la puerta X actúa como entrada.

Cuando se produce un reset TRIS se pone a 1, configurando así las puertas como entradas y
evitando que se active indebidamente algún dispositivo externo que estuviera conectado al
PIC.



La configuración típica para las puertas E/S se ve en la figura 2.17.

Figura 2.17 Diagrama de bloques típico de una puerta E/S.

2.7 Modo de reposo o SLEEP.

El modo de reposo o SLEEP, hace entrar al dispositivo en el estado de menor consumo de
potencia. En este modo deja de funcionar el oscilador principal, así como los temporizadores
del dispositivo, salvo el Watchdog, y además las líneas E/S mantienen su estado. Para acceder
al modo de reposo se utiliza la instrucción SLEEP.

Para obtener el mínimo consumo habría que desconectar los periféricos y las líneas E/S
deberían conectarse a VDD o VSS.

Las formas de salir del modo de reposo son:
1. Cualquier reset del dispositivo.
2. Rebose del Watchdog (si éste está activado).



3. Mediante cualquier interrupción producida mientras el dispositivo está en el modo
de reposo, tal como:
a. Flanco en el pin RB0/INT.
b. Cambio de estado en líneas de puerta.
c. Comparadores.
d. Conversores A/D.
e. Overflow en TMR1.
f. LCD.
g. Interrupción por puerto serie síncrono, SSP.
h. Módulos de captura.

Al salir del modo de reposo se ejecuta la siguiente instrucción a SLEEP.


Microcontroladores PIC de la Gama Media. 3. Juego de instrucciones de los PIC de la Gama Media.

Capítulo 3. Juego de instrucciones de los PIC de la Gama
Media.

3.1 Introducción.

Las características del juego de instrucciones vienen determinadas por el tipo de arquitectura
que tienen los PIC:
• La arquitectura Harvard,
• Conjunto de instrucciones reducido (RISC).

Esto implica que:
a) Normalmente el bus de instrucciones es mayor que el de datos. De esta forma se
obtiene una mayor eficiencia adaptando los anchos de los buses a los
requerimientos de la arquitectura y, por tanto, se optimiza el funcionamiento.
b) Las instrucciones son de una única palabra. Debido a lo anterior se diseñarán
memorias de un ancho igual al código de operación de las instrucciones, pudiendo
acceder a su lectura en un solo ciclo. Además el tamaño de la memoria coincidirá
con el número de instrucciones que podemos almacenar, a diferencia de la
arquitectura Von Neumann, en donde suele existir, de forma general, un ratio de
2:1 (siendo la memoria de 4Kbytes, aproximadamente 2Kbytes son instrucciones).
c) Segmentación de instrucciones. Esto consiste en ejecutar las instrucciones en
distintas fases, unas con acceso a memoria de instrucciones y otras con acceso a
memoria de datos. Al poder realizarse accesos simultáneos a ambas memorias,
podemos ejecutar las instrucciones en un único ciclo de instrucción.
d) El hecho de tener pocas instrucciones facilita el aprendizaje.
e) Arquitectura basada en registros. Todos los elementos de la arquitectura, incluido
el contador de programa (PC), se encuentran mapeados en la memoria de datos,
que a su vez está implementada físicamente como registros.



f) Instrucciones ortogonales: Son aquellas que permiten trabajar con todos los
registros del sistema y con todos los direccionamientos existentes. Esta simetría
permite una programación más eficiente. En la gama media existen únicamente
dos instrucciones no orientadas a registros, que son las instrucciones CLRWDT y
SLEEP.

3.2 Flujo de instrucciones. Segmentación.

La entrada de reloj, se divide internamente por cuatro, obteniéndose cuatro señales de reloj
denominadas Q1, Q2, Q3 y Q4. Internamente, el PC se incrementa cada Q1, la instrucción es
leída de la memoria de instrucciones y almacenada en el registro de instrucciones en Q4. Esa
instrucción es decodificada y ejecutada durante los siguientes Q1-Q4.

El flujo de instrucciones y el reloj se muestran en las figuras 3.1 y 3.2. Además, estos ciclos
son los que denominaremos periodos de oscilación del PIC (Tosc).

Figura 3.1 Flujo de instrucciones y reloj.

Un ciclo de instrucción consiste precisamente en estos 4 ciclos de reloj Q1-Q4, y cada una de
las fases de la instrucción ocupa un ciclo.



Estas dos fases son:
• Fase de búsqueda (Fetch): Se incrementa en Q1 el PC, se lee y se lleva en Q4 a
registro de instrucciones.
• Fase de ejecución: En Q2 se lee la memoria de datos para los operandos y en Q4 se
almacena en la memoria de datos el resultado.

Debido a que en cada una de las fases se accede a una memoria, y que los accesos a memoria
pueden solaparse, aparece la segmentación, es decir, se ejecuta una instrucción por ciclo de
instrucción, excepto las instrucciones de salto incondicional, ya que es en la fase de ejecución
donde se calcula la dirección destino. En este caso tarda dos ciclos de instrucción.

TOSC5
TOSC0 TOSC1 TOSC2 TOSC3 TOSC4
1. MOVLW 55h Buscar 1 Ejecutar 1
2. MOVWF PORTB Buscar 2 Ejecutar 2
3. CALL SUB_1 Buscar 3 Ejecutar 3
4. BSF PORTA,3 Buscar 4 Detención
… Buscar SUB_1 Ejecutar SUB_1
… Buscar SUB_1+1

Figura 3.2 Segmentación de instrucciones

Existen además las instrucciones de salto condicional, que pueden durar 1 ó 2 ciclos en
función del resultado (btfss, btfsc, decfsz y incfsz).

3.3 El formato de las instrucciones.

Las instrucciones de los PIC se pueden dividir en cuatro categorías:
• Instrucciones sobre registros orientadas a bytes.
• Instrucciones sobre registros orientadas a bits.
• Instrucciones para operaciones con literales.
• Instrucciones de control.



Todas ellas tienen un ancho de 14 bits (ancho de la memoria de programa), pero los campos
varían entre ellos.

Los formatos de los distintos tipos de instrucciones son:
• Instrucciones sobre registros orientadas a bytes.
13 8 7 6 0
Código de operación d f

d = 0, resultado se almacena en el acumulador (w).
d = 1, resultado se almacena sobre el propio registro.
f = 7 bits de la dirección del registro sobre el que se realiza la operación.
El resto de la dirección viene dada por los bits RP1, RP0 o IRP.

• Instrucciones sobre registros orientadas a bits.
13 10 9 7 6 0
Código de operación b f

b = 3 bits que indican la posición dentro del registro del bit a modificar.
f = 7 bits de la dirección del registro sobre el que se realiza la operación.
El resto de la dirección viene dada por los bits RP1, RP0 o IRP.

• Instrucciones con literales y de control.
o General.
13 8 7 0
Código de operación k (literal)

k = literal (direccionamiento inmediato).

o Instrucciones GOTO y CALL.
13 11 10 0
Código de operación k (literal)

k = 11 bits menos significativos del PC. El resto se obtiene del PCLATCH.



3.4 Juego de instrucciones.

Primero hay que hacer algunas consideraciones:
• Se puede usar cualquier registro especial como fuente o destino en una instrucción.
• Si usamos el registro de Estado como registro destino, los bits C, Z y DC
obtendrán los valores propios del resultado de la operación. Por ejemplo:
clrf STATUS ; después de su ejecución STATUS = 00001000
; correspondiendo ese 1 con el bit Z.

• Todas las instrucciones que manipulan bit son instrucciones de tipo lectura-
modificación-escritura, es decir, primero se lee el registro, luego se opera y por
último se escribe el resultado. Esto hay que tenerlo en cuenta fundamentalmente
cuando se trabaja sobre las puertas y en éstas se cambian los bits del TRIS
asociadas a ellas.

En la tabla 3.1 se especifica el significado de las distintas abreviaturas que van a ser utilizadas
posteriormente para la descripción detallada de cada una de las instrucciones de los PIC.

TABLA 3.1 Descripción de las abreviaturas utilizadas.
Campo Descripción
f Dirección del registro (0x00 a 0x7F)
w Registro de trabaja (acumulador)
b Posición de un bit de un registro (0 a 7)
k Literal, dato inmediato o dirección de una etiqueta.
x Valor indeterminado (0 ó 1)
Selección el destino;
d d = 0; el resultado se almacena en W.
d = 1; el resultado se almacena en el registro f.
dest Destino (registro W ó f)
TOS Nivel superior de la Pila.
PC Contador de Programa.
PCLATCH Parte alta del Contador de Programa
GIE Bit de activación global de interrupciones.
WDT Perro guardián (Watchdog).
TO Bit “Time Out” del Registro de Estado.
PD Bit “Power Down” del Registro de Estado
[ ] Opciones
( ) Contenido
→ Se asigna a
<> Campo de bits de un registro.



La tabla 3.2 muestra un resumen de todas las instrucciones que componen el lenguaje de
programación de los microcontroladores PIC de la Gama Media.

TABLA 3.2 Instrucciones de la Gama Media.
INSTRUCCIONES SOBRE REGISTROS ORIENTADAS A BYTES
14 bits de la palabra de la Bits de
Nemónicos,
Descripción Ciclos instrucción Estado
Operandos
MSb LSb afectados
ADDWF f, d Suma W y f 1 00 0111 dfff ffff C, DC, Z
ANDWF f, d Y lógica entre W y f 1 00 0101 dfff ffff Z
CLRF f Borra el registro f 1 00 0001 1fff ffff Z
CLRW - Borra el registro W 1 00 0001 0xxx xxxx Z
COMF f, d Complementa f 1 00 1001 dfff ffff Z
DECF f, d Decrementa f 1 00 0011 dfff ffff Z
DECFSZ f, d Decrementa f y salta si es 0 1 (2) 00 1011 dfff ffff
INCF f, d Incrementa f 1 00 1010 dfff ffff Z
INCFSZ f, d Incrementa f y salta si es 0 1 (2) 00 1111 dfff ffff
IORWF f, d O lógica entre W y f 1 00 0100 dfff ffff Z
MOVF f, d Mueve f 1 00 1000 dfff ffff Z
MOVWF f Mueve W a f 1 00 0000 lfff ffff
NOP - No hace nada 1 00 0000 0xx0 0000
RLF f, d Rota f a la izquierda 1 00 1101 dfff ffff C
RRF f, d Rota f a la derecha 1 00 1100 dfff ffff C
SUBWF f, d Resta W de f 1 00 0010 dfff ffff C, DC, Z
SWAPF f, d Intercambia los bytes de f 1 00 1110 dfff ffff
XORWF f, d O lógica exclusiva de W y f 1 00 0110 dfff ffff Z
INSTRUCCIONES SOBRE REGISTROS ORIENTADAS A BITS
BCF f, b Borra el bit b del registro f 1 01 00bb bfff ffff
BSF f, b Pone a 1 el bit b del registro f 1 01 01bb bfff ffff
BTFSC f, b Testea el bit, y salta si es 0 1 (2) 01 10bb bfff ffff
BTFSS f, b Testea el bit y salta si es 1 1 (2) 01 11bb bfff ffff
INSTRUCCIONES CON LITERALES Y DE CONTROL
ADDLW k Suma un literal con el W 1 11 111x kkkk kkkk C, DC, Z
ANDLW k Y lógica entre k y W 1 11 1001 kkkk kkkk Z
CALL k Salto a subrutina 2 10 0kkk kkkk kkkk
CLRWDT - Pone a cero el WDT 1 00 0000 0110 0100 TO , PD
GOTO k Salto incondicional 2 10 1kkk kkkk kkkk
IORLW k O lógica entre k y W 1 11 1000 kkkk kkkk Z
MOVLW k Mueve el literal k a W 1 11 00xx kkkk kkkk
RETFIE - Retorno de interrupción 2 00 0000 0000 1001
RETLW k Retorno con k en W 2 11 01xx kkkk kkkk
RETURN - Retorno de subrutina 2 00 0000 0000 1000
SLEEP - Modo de reposo 1 00 0000 0110 0011 TO , PD
SUBLW k 1 11 110x kkkk kkkk C, DC, Z
XORLW k O exclusiva entre k y W 1 11 1010 kkkk kkkk Z



3.4.1 Descripción detallada de las instrucciones por orden alfabético.

ADDLW Suma Literal con el W

Sintaxis: [etiqueta] ADDLW k
Operandos: 0 ≤ k ≤ 255
Operación: (W) + k → W
Flags afectados: C, DC, Z
Código OP: 11 111x kkkk kkkk
Descripción: El contenido del registro W se suma con los ocho bits del literal
“k”, almacenando el resultado en W.
Ejemplo ADDLW 0X15
Antes de la instrucción W = 0x10
Después de la instrucción W= 0x25

ADDWF Suma W y el registro f

Sintaxis: [etiqueta] ADDWF f, d
Operandos: 0 ≤ f ≤ 127
d є [0, 1]
Operación: (W) + (f) → dest
Código OP: 00 0111 dfff ffff
Descripción: Suma el contenido del registro W y el registro “f”. Si “d” es 0,
el resultado se almacena en el registro W, mientras que si es 1
se almacena en el registro “f”.
Ejemplo: ADDWF FSR, 0
FSR = 0xC2
Después de la instrucción W = 0xD9
FSR = 0xC2



ANDLW Y lógica entre Literal y W

Sintaxis: [etiqueta] ANDLW k
Operación: (W) AND (k) → W
Flags afectados: Z
Código OP: 11 1001 kkkk kkkk
Descripción: Realiza la operación lógica AND entre el registro W y los ocho
bits del literal “k”. El resultado se almacena en el registro W.
Ejemplo: ANDLW 0x5F
Antes de la instrucción W = 0xA3 ;0101 1111 (0x5F)
Después de la instrucción W = 0x03 ;1010 0011 (0xA3)
;0000 0011 (0x03)

ANDWF Y lógica entre W y f

Sintaxis: [etiqueta] ANDWF f, d
d є [0, 1]
Operación: (W) AND (f) → dest
Flags afectados: Z
Descripción: Realiza la operación lógica AND entre W y el registro “f”. Si
“d” es 0, el resultado se almacena en el registro W, mientras
que si es 1 se almacena en el registro “f”.
Ejemplo: ANDWF FSR, 1
Antes de la instrucción W = 0x17 ;0001 0111 (0x17)
FSR = 0xC2 ;1100 0010 (0xC2)
Después de la instrucción W = 0x17 ;0000 0010 (0x02)
FSR = 0x02



BCF Borra un bit

Sintaxis: [etiqueta] BCF f, b
0≤b≤7
Operación: 0 → f<b>
Flags afectados: Ninguno
Código OP: 01 00bb bfff ffff
Descripción: Borra el bit “b” del registro “f”.
Ejemplo: BCF FLAG_REG, 7
Antes de la instrucción FLAG_REG = 0xC7 ;1100 0111
Después de la instrucción FLAG_REG = 0x47 ;0100 0111

BSF Pone a 1 un bit

Sintaxis: [etiqueta] BSF f, b
0≤b≤7
Operación: 1 → f<b>
Descripción: Pone a 1 el bit “b” del registro “f”.
Ejemplo: BSF FLAG_REG, 7
Antes de la instrucción FLAG_REG = 0x0A ;0000 1010
Después de la instrucción FLAG_REG = 0x8A ;1000 1010



BTFSC Testeo de bit y salto si es 0

Sintaxis: [etiqueta] BTFSC f, b
0≤b≤7
Operación: Salta si (f<b>) = 0
Descripción: Si el bit “b” del registro “f” es 0, se salta una instrucción y se
continua con la ejecución.
Ejemplo: AQUÍ BTFSC FLAG, 4
FALSO GOTO REPETIR
VERDAD ..........
..................................
Antes de la instrucción PC = dirección de AQUÍ
Después de la instrucción Si FLAG, 4 =0
PC = dirección de VERDAD
Si FLAG, 4 = 1
PC = dirección de FALSO

BTFSS Testeo de bit y salto si es 1

Sintaxis: [etiqueta] BTFSS f, b
0≤b≤7
Operación: Salta si (f<b>) = 1
Descripción: Si el bit “b” del registro “f” es 1, se salta una instrucción y se
continua con la ejecución.
Ejemplo: AQUÍ BTFSS FLAG, 4
FALSO GOTO REPETIR
VERDAD ..........
..................................
Antes de la instrucción PC = dirección de AQUÍ
Después de la instrucción Si FLAG, 4 =1
PC = dirección de VERDAD
Si FLAG, 4 = 0
PC = dirección de FALSO



CALL Salto a subrutina

Sintaxis: [etiqueta] CALL k
Operación: (PC) + 1 → TOS,
k → PC<10:0>,
(PCLATCH<4:3>) → PC<12:11>
Código OP: 10 0kkk kkkk kkkk
Descripción: Salto a subrutina. Primero se guardan en la pila los 13 bits de
la dirección de retorno (PC + 1). Después se carga en el PC los
11 bits del inmediato “k”, los dos bits más significativos los
proporciona el PCLATCH<4:3>. CALL tarda dos ciclos de
instrucción en ejecutarse.
Ejemplo: PROGRAMA CALL SUBRUTINA
Antes de la instrucción PC =dirección de PROGRAMA
Después de la instrucción TOS = dirección de PROGRAMA + 1
PC = dirección de SUBRUTINA

CLRF Borra un registro f

Sintaxis: [etiqueta] CLRF f
Operación: 00h → f
1→Z
Flags afectados: Z
Código OP: 00 0001 1fff ffff
Descripción: Se borra el contenido del registro “f” y el flag Z de estado se
activa.
Ejemplo: CLRF FLAG_REG
Antes de la instrucción FLAG_REG = 0x5A
Después de la instrucción FLAG_REG = 0x00
Z=1



CLRW Borra el registro W

Sintaxis: [etiqueta] CLRW
Operandos: Ninguno
Operación: 00h → W
1→Z
Flags afectados: Z
Código OP: 00 0001 1xxx xxxx
Descripción: Se borra el contenido del registro W y el flag Z de estado se
activa.
Ejemplo: CLRW
Antes de la instrucción W = 0x5A
Después de la instrucción W = 0x00
Z=1

CLRWDT Borra el “Watchdog”

Sintaxis: [etiqueta] CLRWDT
Operandos: Ninguno
Operación: 00h → WDT
0 → predivisor del WDT
1 → TO
1 → PD
Flags afectados: TO , PD
Código OP: 00 0000 0110 01000
Descripción: Se borra el contenido tanto del “Watchdog” como de su
predivisor. Los bits TO y PD del Registro de Estado se ponen
a 1.
Ejemplo: CLRWDT
Antes de la instrucción Temporizador WDT =x
Predivisor WDT = 1:128
Después de la instrucción Temporizador WDT = 0x00
Registro predivisor WDT =0
TO =1
PD =1
Predivisor WDT = 1:128



COMF Complementa el registro f

Sintaxis: [etiqueta] COMF f, d
d є [0, 1]
Operación: ( f ) → dest
Flags afectados: Z
Descripción: Complementa el contenido del registro “f”. Si “d” es 0, el
resultado se almacena en el registro W, mientras que si es 1 se
almacena en el registro “f”.
Ejemplo: COMF REG1, 0
Antes de la instrucción REG1 = 0x13
Después de la instrucción REG1 = 0x13
W = 0xEC

DECF Decrementa el registro f

Sintaxis: [etiqueta] DECF f, d
d є [0, 1]
Operación: (f) - 1 → dest
Flags afectados: Z
Descripción: Decrementa el contenido del registro “f”. Si “d” es 0, el
Ejemplo: DECF CONT, 1
Antes de la instrucción CONT = 0x01
Z =0
Después de la instrucción CONT = 0x00
Z =1



DECFSZ Decrementa el registro f y salta si es 0

Sintaxis: [etiqueta] DECFSC f, d
d є [0, 1]
Operación: (f) – 1 → dest; salta si el resultado es 0
Descripción: Decrementa el contenido del registro “f”. Si “d” es 0, el
almacena en el registro “f”. Si el resultado es 0, se salta la
siguiente instrucción y se continua con la ejecución.
Ejemplo: RESTA DECFSZ CONT, 1
GOTO LAZO
CONTINUAR ...........
..............................................
Antes de la instrucción PC = dirección de RESTA
CONT = 0x01
PC = dirección de CONTINUAR

GOTO Salto Incondicional

Sintaxis: [etiqueta] GOTO k
Operación: k → PC<10:0>
PCLATCH<4:3> → PC<12:11>
Código OP: 10 1kkk kkkk kkkk
Descripción: Salto incondicional. Se carga en el PC<10:0> los 11 bits del
inmediato “k”. Los dos bits restantes los proporciona el
PCLATCH<4:3>. GOTO tarda dos ciclos de instrucción en
ejecutarse.
Ejemplo: GOTO SALTO
Después de la instrucción PC = dirección SALTO



INCF Incrementa el registro f

Sintaxis: [etiqueta] INCF f, d
d є [0, 1]
Operación: (f) + 1 → dest
Flags afectados: Z
Descripción: Incrementa el contenido del registro “f”. Si “d” es 0, el
Ejemplo: INCF CONT, 1
Antes de la instrucción CONT = 0xFF
Z =0
Z =1

INCFSZ Incrementa el registro f y salta si es 0

Sintaxis: [etiqueta] INCFSC f, d
d є [0, 1]
Operación: (f) + 1 → dest; salta si el resultado es 0
Descripción: Incrementa el contenido del registro “f”. Si “d” es 0, el
almacena en el registro “f”. Si el resultado es 0, se salta la
siguiente instrucción y se continua con la ejecución.
Ejemplo: SUMA INCFSZ CONT, 1
GOTO LAZO
CONTINUAR ...........
..............................................
Antes de la instrucción PC = dirección de RESTA
CONT = 0xFF
PC = dirección de CONTINUAR



IORLW O lógica entre Literal y W

Sintaxis: [etiqueta] IORLW k
Operación: (W) OR (k) → W
Flags afectados: Z
Descripción: Realiza la operación lógica OR entre el registro W y los ocho
bits del literal “k”. El resultado se almacena en el registro W.
Ejemplo: ANDLW 0x35
Antes de la instrucción W = 0x9A
Después de la instrucción W = 0xBF
Z =0

IORWF O lógica entre W y f

Sintaxis: [etiqueta] IORWF f, d
d є [0, 1]
Operación: (W) OR (f) → dest
Flags afectados: Z
Descripción: Realiza la operación lógica OR entre W y el registro “f”. Si
“d” es 0, el resultado se almacena en el registro W, mientras
que si es 1 se almacena en el registro “f”.
Ejemplo: IORWF REG, 0
Antes de la instrucción REG = 0x13
W = 0x91
Después de la instrucción REG = 0x13
W = 0x93
Z =0



MOVLW Mueve un Literal a W

Sintaxis: [etiqueta] MOVLW k
Operación: k→W
Código OP: 11 00xx kkkk kkkk
Descripción: El registro W se carga con el valor de los ocho bits del literal
“k”.
Ejemplo: MOVLW 0x5A
Después de la instrucción W = 0x5A

MOVF Mover a f

Sintaxis: [etiqueta] MOVF f, d
d є [0, 1]
Operación: (f) → dest
Flags afectados: Z
Descripción: El contenido del registro “f” se mueve al destino. Si “d” es 0,
el resultado se almacena en el registro W, mientras que si es 1
se almacena en el registro “f”.
Ejemplo: MOVF FSR, 0
FSR = 0xC2
Después de la instrucción W = 0xC2
Z =0



MOVWF Mueve W al registro f

Sintaxis: [etiqueta] MOVWF f
Operación: (W) → f
Código OP: 00 0000 1fff ffff
Descripción: Mueve el contenido del registro W al registro “f”.
Ejemplo: MOVWF OPTION_REG
Antes de la instrucción OPTION_REG = 0xFF
W = 0x4F
Después de la instrucción OPTION_REG = 0x4F
W = 0x4F

NOP No operar

Sintaxis: [etiqueta] NOP
Operandos: Ninguno
Operación: No realiza ninguna operación
Código OP: 00 000 0xx0 0000
Descripción: No realiza ninguna operación.
Ejemplo: ETIQUETA NOP
Antes de la instrucción PC = dirección de ETIQUETA
Después de la instrucción PC = dirección de ETIQUETA + 1



RETFIE Retorno de rutina de interrupción

Sintaxis: [etiqueta] RETFIE
Operandos: Ninguno
Operación: TOS → PC
1 → GIE
Código OP: 00 0000 0000 1001
Descripción: Retorno de una rutina de interrupción. Los 13 bits de la
dirección de retorno los carga en el PC desde la pila. El bit
GIE (INTCON<7>) se pone automáticamente a 1, habilitando
nuevas interrupciones. Requiere dos ciclos de instrucción para
su ejecución.
Ejemplo: RETFIE
Después de la instrucción PC = TOS
GIE = 1

RETLW Retorno de subrutina con Literal en el W

Sintaxis: [etiqueta] RETLW k
Operación: k→W
TOS → PC
Código OP: 11 01xx kkkk kkkk
Descripción: El registro W se carga con los ocho bits del literal “k”. El PC
toma los 13 bits de la dirección de retorno del nivel superior de
la pila. Requiere dos ciclos de instrucción para su ejecución.
Ejemplo: PROGRAMA CALL TABLA
.................
.................
TABLA ADDWF PC
RETLW k0
RETLW k1
...........................
RETLW kn
Después de la instrucción W = valor de k7
PC= TOS = dirección de PROGRAMA +1



RETURN Retorno de subrutina

Sintaxis: [etiqueta] RETURN
Operandos: Ninguno
Operación: TOS → PC
Código OP: 00 0000 0000 1000
Descripción: Retorno de una subrutina de interrupción. Los 13 bits de la
dirección de retorno los carga en el PC desde la pila. Requiere
dos ciclos de instrucción para su ejecución.
Ejemplo: FIN RETURN
Después de la instrucción PC = TOS

RLF Rota f a la izquierda a través del Carry

Sintaxis: [etiqueta] RLF f, d
d є [0, 1]
Operación: Rotación a la izquierda de f.
Flags afectados: C
Descripción: El contenido del registro “f” se rota una posición a la izquierda
a través del flag de carry. Si “d” es 0, el resultado se almacena
en el registro W, mientras que si es 1 se almacena en el
registro “f”.
C Registro f

Ejemplo: RLF REG1, 0
Antes de la instrucción REG1 = 1110 0110
C =0
Después de la instrucción REG1 = 1110 0110
W = 1100 1100
C =1



RRF Rota f a la derecha a través del Carry

Sintaxis: [etiqueta] RRF f, d
d є [0, 1]
Operación: Rotación a la derecha de f.
Flags afectados: C
Descripción: El contenido del registro “f” se rota una posición a la derecha a
través del flag de carry. Si “d” es 0, el resultado se almacena
en el registro W, mientras que si es 1 se almacena en el
registro “f”.
C Registro f

Ejemplo: RLF REG1, 0
Antes de la instrucción REG1 = 1110 0110
C =0
Después de la instrucción REG1 = 1110 0110
W = 0111 0011
C =0

SLEEP Modo de reposo

Sintaxis: [etiqueta] SLEEP
Operandos: Ninguno
Operación: 00h → WDT
0 → predivisor del WDT
1 → TO
0 → PD
Flags afectados: TO , PD
Código OP: 00 0000 0110 0011
Descripción: El bit TO se pone a 1, y el bit PD del registro de Estado se
pone a 0. Además también se pone a cero el predivisor del
predivisor del WDT. El procesador entra en el modo SLEEP o
de reposo, dejando el oscilador principal de funcionar.
Ejemplo: SLEEP



SUBLW Resta W de un Literal

Sintaxis: [etiqueta] SUBLW k
Operación: k – (W) → W
Código OP: 11 110x kkkk kkkk
Descripción: El registro W se resta (mediante complemento a 2) de los ocho
bits del literal “k”. El resultado es almacenado en el registro
W.
Ejemplo: SUBLW 0x02
C =x
Z=x
Después de la instrucción W = 0x01
C=1 ;el resultado es positivo
Z=0

SUBWF Resta W del registro f

Sintaxis: [etiqueta] SUBWF f, d
d є [0, 1]
Operación: (f) - (W) → dest
Descripción: El registro W se resta (mediante complemento a 2) del registro
“f”. Si “d” es 0, el resultado se almacena en el registro W,
mientras que si es 1 se almacena en el registro “f”.
Ejemplo: SUBWF REG1, 1
Antes de la instrucción REG1 =3
W =2
C =x
Z =x
Después de la instrucción REG1 =1
W =2
C =1 ;el resultado es positivo
Z =0



SWAPF Intercambio de los Nibbles del registro f

Sintaxis: [etiqueta] SWAPF f, d
d є [0, 1]
Operación: (f<3:0>) → dest<7:4>
(f<7:4>) → dest<3:0>
Descripción: Los cuatro bits más significativos y menos significativos del
registro “f”, son intercambiados entre si. Si “d” es 0, el
Ejemplo: SWAPF REG1, 0
Antes de la instrucción REG1 = 0xA5
Después de la instrucción REG1 = 0xA5
W = 0x5A

XORLW O exclusiva entre un Literal y W

Sintaxis: [etiqueta] XORLW k
Operación: (W) XOR (k) → W
Flags afectados: Z
Descripción: Realiza la operación lógica O exclusiva entre el registro W y
los ocho bits del literal “k”. El resultado es almacenado en el
registro W.
Ejemplo: XORLW 0xAF ;1010 1111 (0xAF)
Antes de la instrucción W = 0xB5 ;1011 1010 (0xB5)
Después de la instrucción W = 0x1A ;--------------- ---------
Z=0 ;0001 1010 (0x1A)



XORWF O exclusiva entre W y el registro f

Sintaxis: [etiqueta] XORWF f, d
d є [0, 1]
Operación: (W) XOR (f) → dest
Flags afectados: Z
Descripción: Realiza la operación lógica O exclusiva entre el registro W y el
registro “f”. Si “d” es 0, el resultado se almacena en el registro
W, mientras que si es 1 se almacena en el registro “f”.
Ejemplo: XORWF REG, 1
Antes de la instrucción REG = 0xAF ;1010 1111 (0xAF)
W = 0xB5 ;1011 1010 (0xB5)
Después de la instrucción REG = 0x1A ;--------------- ---------
W = 0xB5 ;0001 1010 (0x1A)


Microcontroladores PIC de la Gama Media. 4. Los Periféricos de los PIC de la Gama Media.

Capítulo 4. Los Periféricos de los PIC de la Gama Media

4.1 Introducción.

En este capítulo se tratará el estudio de los distintos periféricos de los PIC de la Gama Media.
Una de las ventajas que tienen los PIC es la gran cantidad de periféricos asociados a los
modelos que hay. Estos periféricos sirven para interactuar con el exterior a través de una
circuitería externa adecuada.

4.2 Interrupciones.

Existen fundamentalmente dos métodos de E/S:

• E/S controlada por programa, en la cual se testea de forma continua mediante un
bucle el estado de los elementos externos o periféricos, actuando en
correspondencia a los valores obtenidos.
• E/S controlada por interrupciones. En este caso el elemento externo o periférico
le indica al microcontrolador cuando está preparado, pudiendo mientras realizar
otras tareas. Cuando se produce la interrupción el microcontrolador atiende al
periférico que la ha producido y luego continua con la tarea que estaba haciendo
anteriormente.

Este último método es el más potente para realizar operaciones de E/S, y los PIC de la Gama
Media permiten la posibilidad de usarlo. A diferencia de otros sistemas, estas interrupciones
no están vectorizadas.



Según el modelo que se use, se podrán producir distintas interrupciones. Las fuentes posibles
de generación de interrupciones son:
• Interrupción por flanco en el pin RB0/INT (interrupción externa).
• Interrupción por rebose del TMR0.
• Interrupción por cambio de nivel en PORTB(RB7:RB4).
• Interrupción por cambio en el comparador.
• Interrupción del puerto paralelo esclavo.
• Interrupción de la USART (tanto recepción como transmisión).
• Interrupción por finalización de conversión A/D.
• Interrupción de LCD.
• Interrupción por finalización de escritura en memoria de datos EEPROM.
• Interrupción del módulo CCPx.
• Interrupción del módulo SSP (comunicación serie).

Cada una de estas interrupciones tiene dos bits asociados:
- <nombre>E → Habilitación de la interrupción.
- <nombre>F → Flag de interrupción (indica que se ha producido el
evento de esa interrupción).
Los bits de habilitación van a venir almacenados en los registros INTCON, PIE1 y PIE2, y los
flags lo harán en los registros INTCON, PIR1 y PIR2. De estos registros el más corriente es el
registro INTCON que aparece siempre, almacenando tanto habilitaciones como flags,
mientras que los otros dependerán del modelo que se tenga.

Existen dos flags que habilitan de forma global las interrupciones, estos son:
• GIE (INTCON<7>): Habilita de forma global todas las interrupciones del PIC
(GIE=1).
• PEIE (INTCON<6>): Habilita de forma global todas las interrupciones de los
periféricos, es decir, todas excepto las asociadas a la puerta A, flanco por



RB0/INT, cambio de estado en RB4:RB7 y rebose del TMR0. Estas están todas en
el registro INTCON.
Existen algunos PIC que únicamente tienen un periférico (memoria de datos
EEPROM o conversor A/D). En este caso, este flag de habilitación está sustituido
por el de habilitación de interrupción por ese periférico, EEIE o ADIE.

4.2.1 Registros de control.

Los registros de control de las interrupciones, como se ha dicho anteriormente, son el registro
INTCON, y los registros PIR y PIE.

4.2.1.1 Registro INTCON.

En este registro se encuentran las habilitaciones y señalizadores de las interrupciones más
comunes, así como las habilitaciones globales de las interrupciones.

GIE PEIE(3) T0IE INTE(2) RBIE(1,2) T0IF INTF(2) RBIF(1,2)
bit7 bit0

bit 7 GIE: Bit de habilitación global de interrupciones.
1 = Interrupciones habilitadas.
0 = Interrupciones deshabilitadas.
bit 6 PEIE: Bit de habilitación de interrupciones de los periféricos.
1 = Habilitadas interrupciones de los periféricos.
0 = Deshabilitadas interrupciones por los periféricos.
bit 5 T0IE: Habilitación de interrupción por rebose del TMR0
1 = Habilitada interrupción por rebose del TMR0
0 = Deshabilitada interrupción por rebose del TMR0.
bit 4 INTE: Habilitación de interrupción por flanco en RB0/INT.
1 = Habilitada.
0 = Deshabilitada.
bit 3 RBIE(1): Habilitación de interrupción por cambio de estado en
PORTB<7:4>.
1 = Habilitada.
0 = Deshabilitada.



bit 2 T0IF: Señalizador de rebose del TMR0.
1 = TMR0 ha rebosado. Se borra por software.
0 = No se ha producido rebose.
bit 1 INTF: Señalizador de interrupción por flanco en RB0/INT.
1 = La interrupción se ha producido. Se borra por software.
0 = No se ha producido interrupción.
bit 0 RBIF(1): Señalizador de cambio de estado en PORTB<7:4>.
1 = Ha cambiado de estado alguna de las líneas, RB<7:4> .
0 = No ha cambiado ninguna entrada.

Nota 1: En algunos dispositivos, los bits RBIE y RBIF son conocidos como GPIE y GPIF respectivamente.
Nota 2: Algunos dispositivos no tienen esta característica. En este caso el bit está reservado.
Nota 3: En dispositivos con una sola interrupción de periféricos, este bit puede ser EEIE o ADIE.

4.2.1.2 Registros PIE.

Dependiendo del número de fuentes de interrupción producidas por periféricos que posea el
dispositivo, puede haber múltiples registros para la habilitación de éstas (PIE1, PIE2). Para
que la configuración de estos registros PIE sea válida, el bit PEIE del registro INTCON ha de
estar a 1, en caso contrario las interrupciones estarán deshabilitadas.

R/W-0
(Nota 1)
bit 7 bit 0

bit TMR1IE: Habilitación de interrupción por rebose del TMR1.
1 = Habilitada interrupción por rebose del TMR1.
0 = Deshabilitada interrupción por rebose del TMR1.
bit TMR2IE: Habilitación de interrupción por igualación del TMR2 y
PR2.
1 = Habilitada
0 = Deshabilitada
bit CCP1IE: Habilitación de interrupción del módulo CCP1.
1 = Interrupción habilitada.
0 = Interrupción deshabilitada.
bit CCP2IE: Habilitación de interrupción del módulo CCP2.
bit SSPIE: Habilitación de interrupción del Puerto Serie Síncrono.



bit RCIE: Habilitación de interrupción por recepción de la USART.
bit TXIE: Habilitación de interrupción por transmisión de la USART.
bit ADIE: Habilitación de interrupción por conversión A/D.
bit ADCIE: Habilitación de interrupción en el convertidor de rampa A/D.
bit OVFIE: Habilitación de interrupción por rebose del temporizador del
convertidor de rampa A/D.
bit PSPIE: Habilitación de interrupción por lectura/escritura del Puerto
Paralelo Esclavo.
1 = Habilitada interrupción por lectura/escritura del PSP.
bit EEIE: Habilitación de interrupción por escritura en EEPROM.
bit LCDIE: Habilitación de interrupción del LCD.
bit CMIE: Habilitación de interrupción del comparador.

Nota 1: La posición de los distintos bits dentro de los registros PIE1 y PIE2 dependen del modelo del
que se trate, por lo que habrá que consultar las hojas de características.

4.2.1.3 Registros PIR.

Al igual que ocurre con los registros PIE, dependiendo del número de fuentes de interrupción
producidas por periféricos que posea el dispositivo, puede haber múltiples registros para la
señalización de éstas (PIR1, PIR2).

Estos flags de señalización han de ser borrados por software.



R/W-0
(Nota 1)
bit 7 bit 0

bit TMR1IF: Señalización de interrupción por rebose del TMR1.
1 = Se ha producido rebose del TMR1. Se borra por software.
0 = No ha habido rebose del TMR1.

bit TMR2IF: Flag de interrupción por igualación del TMR2 con PR2.
1 = TMR2 se ha igualado con PR2. Se borra por software.
0 = El TMR2 no se ha igualado con el PR2.
bit CCP1IF: Flag de interrupción CCP1.
modo captura.
1 = Se ha producido una captura del TMR1. Se borra por software.
0 = No se ha producido ninguna captura.
modo comparación.
1 = El TMR1 se ha igualado con el registro de comparación.
Se borra por software.
0 = No se ha igualado el TMR1 con el registro de comparación.
modo PWM.
No se utiliza en este modo.
bit CCP2IF: Flag de interrupción CCP2.
modo de captura.
1 = Se ha producido una captura del TMR1. Se borra por software.
0 = No se ha producido ninguna captura.
modo de comparación.
1 = El TMR1 se ha igualado con el registro de comparación.
Se borra por software.
0 = No se ha igualado el TMR1 con el registro de comparación.
modo PWM.
bit SSPIF: Flag de interrupción del puerto serie síncrono.
1 = La transmisión/recepción se ha realizado.
0 = Esperando a transmitir/recibir.
bit RCIF: Flag de interrupción por recepción de la USART.
1 = El buffer de recepción de la USART está lleno. Se borra leyendo el
registro RCREG.
0 = El buffer de recepción de la USART está vacío.
bit TXIF: Flag de interrupción por transmisión de la USART.
1 = El buffer de transmisión de la USART, TXREG, está vacío. Se
borra escribiendo en el registro TXREG.
0 = El buffer de transmisión de la USART está lleno.
bit ADIF: Flag de interrupción del convertidor A/D.
1 = Conversión A/D completa. Se borra por software.
0 = La conversión no se ha completado.



bit ADCIF: Flag de interrupción del convertidor por rampa A/D.
1 = La conversión A/D se ha completado. Se borra por software.
0 = La conversión no ha terminado..
bit OVFIF: Flag de interrupción por rebose del temporizador del
convertidor de rampa A/D.
1 = El temporizador del convertidor A/D ha rebosado.
(Se borra por software).
0 = El temporizador no ha rebosado.
bit PSPIF: Señalización de interrupción por lectura/escritura del Puerto
Paralelo Esclavo.
1 = Se ha realizado una operación de lectura o escritura.
0 = No se ha realizado ninguna operación de lectura ni escritura.
bit EEIF: Señalizador de escritura completa en la EEPROM de datos.
1 = La operación de escritura de la EEPROM de datos ha terminado.
0 = La operación de escritura de la EEPROM de datos no ha terminado.
bit LCDIF: Flag de interrupción del LCD.
1 = Se ha producido una interrupción del LCD. Se borra por software.
0 = No se ha producido una interrupción del LCD.
bit CMIF: Señalización de interrupción por el comparador.
1 = Cambio en la salida del comparador.
0 = La salida del comparador no ha cambiado.

Nota 1: La posición de los distintos bits dentro de los registros PIE1 y PIE2 dependen del modelo del
que se trate, por lo que habrá que consultar las hojas de características.

En la figura 4.1 se muestran todos los bits implicados en la activación y detección de las
interrupciones en los PIC de la Gama Media. Cada bit sólo aparece en determinados modelos,
según los periféricos que tenga implementado, por lo que será necesario consultar las hojas
características de cada dispositivo.

Algunos modelos tienen una sola interrupción por periféricos, en este caso el bit PEIE suele
ser sustituido por el bit concreto del periférico (EEIE o ADIE).



Figura 4.1 Lógica de control de interrupciones.

4.2.2 Fases de una interrupción.

Las fases de ejecución de una interrupción, partiendo de que GIE=1, <interrupción>E=1 y
PEIE=1 si fuese necesario, son:
1. Se produce el suceso que desencadena la interrupción. <interrupción>F=1.
2. Aproximadamente pasado un ciclo de instrucción GIE se pone a 0. De esta forma,
no se producirán interrupciones mientras tratemos a la actual.
3. En el siguiente ciclo de instrucción el Contador de Programa se guarda en la pila, y
se carga en él la dirección 0004h (vector de interrupción).
4. En el siguiente ciclo se empieza a ejecutar la instrucción que se encuentra en el
vector de interrupción.



5. Antes de realizar el retorno de la rutina de interrupción se han de borrar los
señalizadores por software, para que no vuelva a entrar en la rutina.
6. Para terminar se recupera el valor del PC de la pila y se pone el bit GIE de nuevo a
‘1’.

Desde que ocurre una interrupción hasta que empieza a ejecutarse la rutina correspondiente,
en el mejor de los casos, pasa un tiempo igual a tres veces el periodo del ciclo de instrucción,
para interrupciones síncronas de tipo internas. En el caso de interrupciones asíncronas
externas puede ir desde los 3TCY hasta 3.75TCY. A esto es a lo que se le conoce como latencia
de interrupción. El tiempo exacto de latencia depende de en que fase del ciclo de instrucción
se produzca la interrupción (figura 4.2 ).

Figura 4.2 Flujo de señales de una interrupción por el pin INT.

Nota 1: El flag INTF se testea aquí (en todos los Q1).
2: Latencia = 3-4 TCY, donde TCY es un ciclo de instrucción.
3: CLKOUT está sólo disponible en el modo de oscilador RC.
4: Ver características en AC para saber en mínimo ancho de impulso de INT.



Cuando se produce una interrupción, el único valor que se almacena en la pila es el PC. Esto
lleva a que va a ser necesario almacenar el acumulador y el Registro de Estado en posiciones
de la memoria de datos, volviéndolos a restaurar antes de salir de la rutina de tratamiento de la
interrupción.

Cuando haya varias fuentes de interrupción, habrá que testear cual de ellas es la que se ha
producido. Esto normalmente se hace testeando los flags asociados a las fuentes de
interrupción. El orden de testeo es el que fija la prioridad de las interrupciones. Por ejemplo:

BTFSC INTCON,<BIT fuente1> ; La mayor prioridad corresponde a la fuente1, ya que es la
GOTO FUENTE1 ; primera en ser testeada.
BTFSC INTCON,<BIT fuente2>
GOTO FUENTE2
GOTO FUENTE3

4.3 Puertas de E/S.

Las puertas de E/S son los periféricos más sencillos, permitiendo monitorizar y actuar sobre
otros elementos. Además tienen multiplexadas otras funciones alternativas, en función del
dispositivo del cual se trate, relacionadas con otros periféricos.

Para configurar los pines de las distintas puertas como entradas o como salidas, se utilizan los
registros TRIS. En estos registros un 1 configura la patilla como entrada, mientras que un 0 lo
hace como salida.

Existen siete tipos distintos de puertas E/S, aunque nunca aparecen de forma conjunta todas.
A las puertas E/S se las denomina como PORT<x>, siendo x una letra de la A a la G. Para
poder trabajar adecuadamente con las puertas habrá que ver los consumos máximos
permitidos, tanto en lectura como en escritura, teniendo también en cuenta el número de pines
del puerto que se usen.

Los pines de estas puertas, individualmente, pueden aportar una corriente máxima de salida de
20 mA, y absorber hasta 25 mA. Si trabajan simultáneamente, el máximo valor de corriente



que pueden absorber y aportar entre todas es de 200 mA, para el caso de los puertos A, B, C,
D y E, y de 100 mA para los puertos F y G.

En lo que se refiere a tensiones de entrada en los pines, éstas aceptan valores comprendidos
desde 0.3 a 7.5V en todos los pines salvo en RA4 cuyo rango es desde 0 a 14V. Estos valores
de corrientes y tensión pueden variar según el modelo, por lo que siempre habrá que consultar
las hojas características.

4.3.1 Puerta A.

Son puertas de E/S de hasta 6 pines (en función del modelo) RA0:RA5. Las patillas RA0-
RA3 y RA5 (figura 4.3) pueden actuar como E/S digital compatibles con niveles TTL y
CMOS, o como canales de entrada para el Convertidor A/D, en caso de que éste exista.

Figura 4.3 Diagrama de bloques de las patillas RA3:RA0 y RA5.



La patilla RA4 (figura 4.4) está configurada en drenador abierto, por lo que es necesario
cargarlo en el exterior. A la entrada tiene un buffer de tipo Trigger de Schmitt para
inmunizarlo del ruido.

Esta patilla puede funcionar también como E/S digital y además como entrada del reloj
externo para el TMR0 cuando este actúa como contador.

Figura 4.4 Diagrama de bloques de la patilla RA4.

El registro TRIS asociado a esta puerta es el TRISA. Los bits 6 y 7 de este se leen como ‘0’.



4.3.2 Puerta B.

La puerta B (figura 4.5) está formada por ocho pines de E/S configurables a través del registro
TRISB. Todas ellas disponen de una carga activa interna (carga “pull-up”) implementada con
un CMOS, habilitada siempre que esté actuando como entrada y el bit RBPU del registro
OPTION esté a ‘0’. Se desconecta siempre que el pin trabaje como salida o con un Power-on
Reset.

Figura 4.5 Diagrama de bloques de las patillas RB3:RB0.



Esta puerta tiene asociada dos tipos de interrupciones:
• A través de RB0/INT: Mediante un flanco de bajada o de subida, según como se
haya configurado en el bit INTEDG (OPTION<6>). El bit para su habilitación es
el INTE (INTCON <4>) y el flag asociado INTF (INTCON<1>).
• A través de los pines RB7:RB4 (figura 4.6): En este caso cada vez que hay un
cambio de nivel se producirá la interrupción, siempre que esté habilitada mediante
el bit RBIE (INTCON<3>). El flag asociado es RBIF (INTCON<0>). La forma de
borrar este bit, además de forzándolo a ‘0’, es realizando una lectura del PORTB.
Mediante este tipo de interrupción se pueden tener distintas fuentes externas que la
produzcan, utilizando un pin distinto para cada una de ellas.

Figura 4.6 Diagrama de bloques de las patillas RB7:RB4.



4.3.3 Puerta C.

La puerta C (figura 4.7) es una puerta de E/S bidireccional de 8 bits configurable a través del
registro TRISC. Este puerto cuando funciona como entrada tiene en ella un Trigger de
Schmitt. Además todos los pines tienen multiplexados la salida y/o la entrada para actuar con
los periféricos.

En la figura 4.7 se puede ver un multiplexor para cuando actúa como salida. Estos periféricos
dependerán del modelo que se esté usando, por lo que habrá que consultar las hojas de
características. Al usar estos periféricos hay que configurar de forma correcta el registro
TRISC, según el periférico necesite un pin de salida o entrada.

Figura 4.7 Diagrama de bloque de los pines del PORTC.



El PORTC tiene sus pines multiplexados con distintos módulos periféricos. Por ejemplo para
el PIC16C74 los módulos periféricos con los que funciona el PORTC son:

• RC0/T1OSO/T1CKI: E/S digital. Salida para el oscilador del TMR1. Entrada de
reloj para el TMR1.
• RC1/T1OSI/CCP2: E/S digital. Entrada para el oscilador del TMR1. E/S del
módulo CCP2.
• RC2/CCP1: E/S digital. E/S del módulo CCP1.
• RC3/SKC/SCL: E/S digital. Reloj serie síncrono para módulos SPI e I2C.
• RC4/SDI/SDA: E/S digital. Entrada de datos para el modo SPI. E/S serie para el
modo I2C.
• RC5/SDO: E/S digital. Salida de datos serie para el modo SPI.
• RC6/TX/CK: E/S digital. Línea de transmisión asíncrona de la USART. Entrada
del reloj síncrono para la USART.
• RC7/RX/DT: E/S digital. Línea de recepción asíncrona para la USART. Línea de
datos síncronos de la USART.

4.3.4 Puerta D.

La puerta D (figura 4.8) está formada por ocho pines de E/S digitales configurables a través
del TRISD. También puede actuar como Puerto Paralelo Esclavo para soportar la conexión
directa con el bus de datos de ocho bits de otro microprocesador.

4.3.5 Puerta E.

Es una puerta de E/S digital de hasta ocho bits (figura 4.8), aunque normalmente sólo tiene
tres. Su función principal es la de actuar como bit de control para la puerta paralela esclava.
Además puede actuar como entrada analógica para el convertidor A/D.



Figura 4.8 Diagrama de bloque de las Puertas D y E.

4.3.6 Puertas F y G.

Las puertas F y G están formadas por ocho pines, los cuales funcionan sólo como entradas.
Cada pin está multiplexado con un controlador para los módulos de LCD. A la entrada, estos
pines tienen un buffer del tipo Trigger de Schmitt (figura 4.9).



Figura 4.9 Diagrama de bloque de los pines del PORTF LCD y PORTG LCD.

4.3.7 Puerta GPIO.

La Puerta GPIO (figura 4.10) es un registro E/S de ocho bits, aunque sólo tiene
implementados los seis más bajos (GP5:GP0). Los bits 7 y 6 se leen como ‘0’. Los pines del
puerto GPIO son programables individualmente como entrada o como salida, excepto el pin
GP3 que es sólo de entrada.

El registro de configuración de esta puerta es el TRISGP que funciona igual que en las
anteriores puertas.



Figura 4.10 Diagrama de bloques de los pines GP5:GP0.

Algunos pines pueden tener funciones alternadas. En este caso la lectura de estos pines del
puerto será ‘0’. Los pines pueden ser configuradas con cargas Pull-up y con generación de
interrupción por cambio de nivel. Estas interrupciones se habilitan con el bit INTCON<3>. Si
se selecciona un oscilador externo en la palabra de configuración del dispositivo, los pines
GP4 y GP5, dejan de funcionar como pines E/S, y lo hacen como entradas para el oscilador.

4.3.9 Operaciones sucesivas en un Puerto E/S.

La escritura en un puerto E/S se realizan al final de un ciclo de instrucción, mientras que las
lecturas lo hacen al principio (figura 4.11). Por esta razón hay que tener cuidado con las
operaciones de escritura en un puerto, seguidas por la lectura de ese mismo puerto. La
secuencia de las instrucciones debe permitir que se estabilicen los voltajes en los pines E/S.
Este tiempo dependerá de la carga que se tenga conectada a la salida. En caso de duda lo más
aconsejable es intercalar instrucciones NOP.



Figura 4.11 Operaciones E/S sucesivas.

Este ejemplo muestra la escritura del puerto B seguido de su lectura. De aquí vemos que el
tiempo para la estabilización de la tensión de salida es de un ciclo de reloj, por lo que altas
frecuencias de reloj estas operaciones de lectura después de las de escritura pueden resultar
problemáticas. Un ejemplo de esto se puede ver en la figura 4.12.

Figura 4.12 Resultado de la activación de una E/S.



4.4 Puerto Paralelo Esclavo.

Los puertos D y E se pueden configurar de modo conjunto para trabajar como Puerto Paralelo
Esclavo (PSP), normalmente controlado por un microprocesador (figura 4.13). En este modo
se podrán leer o escribir de modo asíncrono, ocho bits a través de la Puerta D, utilizando los
bits de control de la Puerta E:
RD = Lectura (RE0).
WR = Escritura (RE1).
CS = Chip Select (RE2).

Para que los puertos D y E trabajen en este modo, hay que poner a ‘1’ el bit PSPMODE
(TRISE<4>). Además las puertas han de estar configuradas como E/S, es decir, que la entrada
del convertidor A/D multiplexada en la puerta E debe de estar deshabilitada. En este modo,
como el flujo de datos a través del PORTD es controlado por el microprocesador, el TRISD
no tiene efecto.

Todos los bits de control se encuentran en el TRISE. Estos bits son:

R-0 R-0 R/W-0 R/W-0 U-0 R/W-1 R/W-1 R/W-1
IBF OBF IBOV PSPMODE -- TRISE2 TRISE1 TRISE0
bit 7 bit 0

bit 7 IBF: Bit de estado del buffer de entrada.
1 = Una palabra ha sido recibida y se está esperando a ser leída por la
CPU.
0 = No se ha recibido ningún dato.
bit 6 OBF: Bit de estado del buffer de salida.
1 = El buffer de salida todavía retiene una palabra previamente escrita.
0 = El buffer de salida ha sido leído.
bit 5 IBOV: Bit de detección de overflow en el buffer de entrada.
1 = A habido una escritura sin que previamente se haya leído el puerto
0 = No ha habido overflow.
bit 4 PSPMODE: Bit de selección del modo Puerto Paralelo Esclavo.
1 = Modo Puerto Paralelo Esclavo.
0 = Modo E/S de propósito general.
bit 3 No implementado: Se lee como ‘0’.



bit 2 TRISE2: Bit de control de dirección del pin RE2.
1 = Entrada.
0 = Salida.
1 = Entrada.
0 = Salida.
1 = Entrada.
0 = Salida.

Figura 4.13 Diagrama de bloques de los Puertos D y E (Puerto Paralelo Esclavo).

a) Operación de escritura:

Para que se produzca una escritura el microprocesador debe poner a cero las líneas
CS y WR . En este momento se carga el registro del PORTD. Al ponerse a uno la
línea CS o WR , se activa el flag IBF (TRISE<7>), indicando que la escritura se ha
completado. El borrado de este flag se produce cuando se realiza una lectura del
Puerto D.



Si se vuelve a producir una escritura del microprocesador sin que se haya leído el
puerto, se producirá un error de overflow del buffer, indicado por el bit IBOV
(TRISE<5>).

Por otra parte al producirse la escritura se activará el flag PSPIF (PIR), que producirá
una interrupción en caso de que esta esté habilitada, es decir PSPIE (PIE) = PEIE =
GIE = 1.

La secuencia de las señales en una operación de escritura se pueden ver en la figura
4.14

Figura 4.14 Flujo de señales de una operación de escritura en modo PSP.

b) Operación de lectura:

Cuando las líneas CS y RD están a cero, se produce el borrado del flag OBF
(TRISE<6>), indicando que se ha realizado una operación de lectura. Cuando alguna
de estas dos líneas se pone a uno, se activa el flag de interrupción PSPIF (PIR). El bit
OBF se mantiene a cero hasta que no se produzca una nueva escritura del PORTD.

En la figura 4.15 se pueden ver las formas de onda de las distintas señales en una
operación de lectura.



Figura 4.15 Flujo de señales en una operación de lectura en el modo PSP.

Los bits IBF y OBF son bit de sólo lectura, por lo que su borrado o activación se produce de
forma automática cuando se realizan operaciones sobre estos puertos.

4.5 Temporizadores.

En los PIC de la Gama Media puede haber hasta tres temporizadores denominados TMR0,
TMR1 y TMR2. Las principales características de cada uno de ellos se muestran a
continuación.

4.5.1 TMR0.

El temporizador TMR0 (Figura 4.16) tiene las siguientes características:
• Contador / temporizador de 8 bits.
• Permite la lectura y escritura.
• Prescaler de 8 bits programable por software.
• Fuente de reloj interna o externa.
• Interrupción por rebose (overflow). De FFh a 00h.
• Selección de flanco para la fuente externa.



Figura 4.16 Diagrama de bloque del TMR0.

Para la configuración del TMR0 se utilizan los bits del registro OPTION<5:0>
bit 5 T0CS: Fuente de reloj para el TMR0.
1 = Pulsos introducidos por T0CKI (contador).
0 = Pulsos de reloj interno Fosc/4 (temporizador).
bit 4 T0SE: Tipo de flanco activo del T0CKI.
1 = Incremento del TMR0 cada flanco descendente.
0 = Incremento del TMR0 cada flanco ascendente.

Valor División del TMR0
000 1:2
001 1:4
010 1:8
011 1:16
100 1:32
101 1:64
110 1:128
111 1:256
Para conseguir un valor del prescaler 1:1, se asigna el divisor de
frecuencia al Perro Guardián.

Cuando se opera con el TMR0 como temporizador (T0CS=0), se produce un incremento de
este cada ciclo de instrucción, siempre que el predivisor esté a 1:1. Al producirse una escritura
sobre el TMR0, este incremento se inhibe durante los dos siguientes ciclos de instrucción
(figura 4.17).



Figura 4.17 Diagrama de tiempos el TMR0, con reloj interno y sin predivisor.

En el caso de que el predivisor de frecuencia esté asignado al TMR0, cuando se escribe sobre
él, el registro del predivisor se pone a cero, y se produce un retardo de dos ciclos de
instrucción más el valor del predivisor hasta que se reinicia la temporización (figura 4.18). En
este caso el incremento del TMR0 se produce cada tantos ciclos de instrucción como valor
tenga el predivisor.

Figura 4.18 Diagrama de tiempos del TMR0 con reloj interno y predivisor 1:2.

Cuando el TMR0 está configurado como contador (T0CS=1), se incrementará cada vez que se
produzca un flanco de bajada o subida, según como este configurado (T0SE), por el pin
T0CKI. Cuando no está configurado el predivisor de frecuencia con el TMR0, la entrada del
reloj externo coincide con la salida del predivisor. La sincronización de la señal T0CKI con la
fase interna del reloj se realiza haciendo un muestreo en la salida del predivisor en cada ciclo
Q2 y Q4. Por esta razón es necesario que los pulsos tengan un ancho mínimo para que se
puedan detectar.



Debido a que la salida del predivisor está sincronizada con el reloj interno, aparece un retardo
desde que se detecta la señal T0CKI hasta que se incrementa el TMR0 (figura 4.19).

Figura 4.19 Diagrama de tiempos del TMR0 con reloj externo.

El temporizador TMR0 tiene asociados los bits T0IE (INTCON<5>) y T0IF (INTCON<2>)
para la habilitación y señalización de interrupción cuando éste rebose, es decir, pase de FFh a
00h.

Como ya se vio en el capítulo 2, el TMR0 tiene un predivisor de frecuencia asociado a él y
compartido con el Perro Guardián o Watchdog.

Para lograr una temporización en concreto hay que inicializar el valor del TMR0 con el valor
adecuado. Para calcular este valor a cargar se utiliza la siguiente expresión:
Ttemp = (256 – VTMR0) · 4 · TOSC · Valor del Predivisor (4.1)

Suponiendo una temporización de 20ms, y un TOSC de 4 MHz, se obtiene:
20 • 10 3
ValorPredivisor = ≈ 78.125 (4.2)
256
El valor siguiente al obtenido es el de predivisor 128, con lo que se obtiene:
20 · 10-3 = (256 – VTMR0) · 10-6 · 128 (4.3)
VTMR0 = 256 – 156 = 100 (4.4)



4.5.2 TMR1.

Es un contador/temporizador ascendente de 16 bits, el cual está implementado con dos
registros de ocho bits que son TMR1H y el TMR1L (figura 4.20).

Figura 4.20 Diagrama de bloques del TMR1.

Como fuentes de los impulsos del reloj existen tres alternativas:
• El oscilador interno del PIC, de modo que el TMR1 se incrementará en cada ciclo
de instrucción.
• Un oscilador externo de tipo XT conectado a RC0/T1OSO/T1CKI y a
RC1/T1OSI/CCP2.
• Contando pulsos externos a través de la patilla RC0/T1OSO/T1CKI.

Para configurar el TMR1 se utiliza el registro T1CON. La estructura de este registro es la
siguiente:



U-0 U-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0
-- -- T1CKPS1 T1CKPS0 T1OSCEN T 1SYNC TMR1CS TMR1ON
bit 7 bit 0

bit 7:6 Bits no implementados: Se leen como ‘0’,
bit 5:4 T1CKPS1:T1CKPS0: Selección del valor del predivisor del reloj de
entrada.
11 = Valor del predivisor 1:8.
bit 3 T1OSCEN: Habilitación del oscilador del TMR1.
1 = Oscilador habilitado.
0 = El oscilador es parado.
bit 2 T1SYNC : Sincronización de la entrada de reloj externa.
Cuando TMR1CS = 1:
1 = No sincronizado con la entrada de reloj interno.
0 = Sincronización de la entrada del reloj externo.
Cuando TMR1CS = 0:
Este bit es ignorado. Ya que utiliza el reloj interno.
bit 1 TMR1CS: Selección de la fuente de reloj para el TMR0.
1 = Reloj externo desde el pin T1OSO/T1CKI (en el flanco de subida).
0 = Reloj interno (FOSC).
bit 0 TMR1ON: Activación del TMR1.
1 = TMR1 activado.
0 = TMR1 parado.

Este periférico cuando pasa de FFFFh a 0000h puede producir una interrupción mediante el
flag TMR1IF (PIR) siempre que estén habilitados los bits TMR1IE (PIE), PEIE
(INTCON<6>) y GIE (INTCON<7>).

Como se puede ver el TMR1 permite funcionar con un predivisor de frecuencia de hasta 1:8.
Cuando actúa con un oscilador externo de tipo XT, dicho reloj puede estar o no sincronizado
con el reloj interno. En el caso de que no lo esté, se puede utilizar para despertar al micro del
modo SLEEP. En caso contrario no, ya que al dejar de funcionar el oscilador principal
también lo haría el TMR1. En modo síncrono se puede utilizar como base de tiempos en
operaciones de Captura y Comparación.



4.5.3 TMR2.

Es un temporizador de 8 bits con un predivisor y un postdivisor asociados (figura 4.21). Si se
usan ambos con su máximo valor, el tiempo para rebosar el TMR2 será semejante a tener un
temporizador de 16 bits.

Figura 4.21 Diagrama de bloque del TMR2.

El registro de configuración del TMR2 es el T2CON que se describe a continuación:

U-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0
-- TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 TMR2ON T2CKPS1 T2CKPS0
bit 7 bit 0

bit 7 Bit no implementado: Se lee como ‘0’.
bit 6:3 TOUTPS3:TOUTPS0: Selección del valor del postdivisor del TMR2.
0000 = Valor del postdivisor 1:1.
.......
.......
bit 2 TMR2ON: Activación del TMR2.
1 = TMR2 activado.
0 = TMR2 parado.



bit 1:0 T2CKPS1:T2CKPS0: Selección del valor del predivisor del TMR2.
1x = Valor del predivisor 1:16.

En el TMR2 aparece un registro llamado PR2 (registro de periodos), que reseteará al TMR2
cuando sean iguales sus valores. A su vez se incrementa el registro del postdivisor, que
cuando rebosa produce una interrupción activando el bit TMR2IF (PIR), siempre que estén
activados los bits TMR2IE (PIE), PEIE y GIE.

Este temporizador únicamente funciona con FOSC /4 del oscilador principal, por lo que a
diferencia del TMR1, no se puede utilizar para sacar al micro del modo SLEEP.

Este temporizador se utiliza como base de tiempos en el modo PWM de los módulos CCP y
es el encargado de generar la señal de reloj síncrona del módulo SSP.

4.6 Módulos CCP.

Los módulos CCP (siendo CCP1 y CCP2) contienen un registro de 16 bits que puede actuar
en los siguientes modos:
• Modo de captura..
• Modo de comparación
• Modo PWM.

Cada uno de los registros CCP tiene asociados tres registros:
• CCPxCON: Registro de control del módulo CCPx.
• CCPRxH: Byte alto del registro de 16 bits.
• CCPRxL: Byte bajo del registro de 16 bits.
• CCPx: pin.



El registro de control CCPCON consta de los siguientes bits:

U-0 U-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0
-- -- DCxB1 DCxB0 CCPxM3 CCPxM2 CCPxM1 CCPxM0
bit 7 bit 0

bit 7:6 Bits no implementados: Se leen como ‘0’.
bit 5:4 DCxB1:DCxB0: Bit1 y bit0 del Duty Cycle del PWM.
Modo captura:
No se usa.
Modo comparación:
No se usa.
Modo PWM:
Son los dos bits menos significativos de los 10 bits que se
utilizan para el Duty Cycle del PWM. Los ocho bits superiores
(DCx9:DCx2) del Duty Cycle se encuentran en CCPRxL.
bit 3:0 CCPxM3:CCPxM0: Bits de selección del modo CCPx.
0000 = Captura/Comparación/PWM apagado (reset del Módulo CCPx).
0100 = Modo de captura, cada flanco de bajada.
0101 = Modo de captura, cada flanco de subida.
0110 = Modo de captura, cada 4 flancos de subida.
0111 = Modo de captura, cada 16 flancos de subida.
1000 = Modo de comparación, inicializar el pin CCP en bajo, y forzarlo
a alto cuando se produzca la igualación.
1001 = Modo de comparación, inicializar el pin CCP en alto, y forzarlo
a bajo cuando se produzca la igualación.
1010 = Modo de comparación, el pin CCP no se ve afectado.
1011 = Modo de comparación
11xx = Modo PWM.

4.6.1 Modo de captura.

En el modo de captura CCPRxH:CCPRxL capturan los 16 bits del registro TMR1 cuando
ocurre un evento en el pin CCPx. Los posibles eventos son:
• Flanco de bajada.
• flanco de subida.
• 4 flancos de subida.
• 16 flancos de subida.



Estos eventos se seleccionan con los bits CCPxM3:CCPxM0 (CCPxCON<3:0>).

Debido a que se trabaja con el TMR1, es necesario que éste funcione como temporizador o
como contador en modo síncrono. En modo asíncrono no funcionaría.

En el momento de la captura en bit CCPxIF (PIR) se activa, produciendo una interrupción en
el caso de que CCPxIE (PIE), GIE y PEIE estén activados también. El flag ha de ser borrado
por software. Si sucede otra captura antes de haber leído el registro CCPRx, el valor de la
captura previa se habrá perdido.

En la figura 4.22 se puede ver el diagrama de bloques del módulo CCPx en modo Captura.

Figura 4.22 Diagrama de bloques en el modo captura.

En este caso el pin CCPx tiene que estar configurado a través del TRISC como entrada. Si
estuviese como salida una escritura en el puerto produciría una condición de captura.

El predivisor se puede utilizar para obtener una resolución media más exacta sobre
frecuencias de entrada constantes. Por ejemplo con un predivisor de 1:16 la resolución
efectiva es de TCY/16, mientras que sin predivisor es de TCY. Cuando el módulo CCP se
“apaga” o el CCP no está en modo captura, el contador del predivisor se borra. Para cambiar



el valor del predivisor habrá que apagar antes el módulo y luego modificarlo, ya que si no se
puede producir una interrupción.
El modo de captura se puede usar para realizar cálculos de tiempos entre varios eventos.

Cuando el dispositivo se encuentra en modo de reposo y aparece en evento externo, el módulo
produce la interrupción que despierta al dispositivo, pero el registro de captura no se
actualiza, ya que el TMR1 no funciona, y el valor cargado carecería de significado.

4.6.2 Modo de comparación.

En este modo los 16 bits del registro CCPRx son comparados constantemente con el
temporizador TMR1. Cuando ambos valores son iguales en el pin CCPx pueden pasar las
siguientes cosas:
• Se pone a valor alto.
• Se pone a valor bajo.
• No cambia.
La acción de pin se controla con los pines de control CCPxM3:CCPxM0 (CCPxCON<3:0>).
Además en cualquier caso se activa el flag CCPxIF, que producirá la interrupción en caso de
que ésta esté habilitada. Para el funcionamiento en este modo el pin CCPx se ha de configurar
como salida mediante el TRIS correspondiente.

En la figura 4.23 muestra el diagrama de bloques del módulo CCP en modo de comparación.



Figura 4.23 Diagrama de bloque en el modo de comparación.
Existe un modo especial que produce un trigger especial, el cual resetea el registro TMR1 (los
16 bits), el cual puede ser utilizado como un temporizador módulo-n. Además en algunos
modelos este trigger dispara la conversión A/D.

4.6.3 Modo PWM.

El modo de modulación por anchura de impulso se utiliza para atacar elementos continuos
con señales discretas. Esto se hace que a través de un puente en H.

En la figura 4.25 se puede ver el diagrama de bloques simplificado del módulo PWM, y en la
figura 4.24 la señal de salida de éste módulo.

Con este módulo se puede obtener una resolución de salida de hasta 10 bits. Para que este
módulo funcione correctamente el pin tiene que estar configurado como salida, mediante el
TRIS correspondiente.



Figura 4.24 Señal PWM.

Figura 4.25 Diagrama de bloques simplificado del módulo PWM.



La generación de la secuencia PWM se obtiene de la siguiente forma:
• En PR2 se escribe el valor del periodo de la señal, el cual se puede calcular con la
siguiente expresión.
PWMT = (PR2 + 1) · 4 · TOSC · (Valor del Predivisor del TMR2) (4.5)
Cuando TMR2 = PR2:
o TMR2 se borra.
o El pin CCPx se pone a ‘1’ ( redivi si el Duty Cycle es ‘0’).
o El valor de CCPRxL junto a CCPxCON<5:4>, se carga sobre CCPRxH, de
forma que se carga el valor del Duty Cycle. Como se puede ver, esto nos da
una resolución de 10 bits, representados por DCxB9:DCxB0.
Para realizar el cálculo del Duty Cycle se utiliza la siguiente ecuación:
PWMDC. = (DCxB9:DCxB0) · TOSC · (Predivisor del TMR2) (4.6)
• Cuando CCPRxH + 2bits = TMR2 + 2bits Qclock (o dos bits del predivisor), la
salida CCPx se pone a ‘0’, terminando con el Duty Cycle.

No todas las resoluciones están permitidas para una frecuencia determinada de PWM. La
resolución máxima en bits viene dada por la expresión:
⎛ Fosc ⎞
log⎜ ⎟
⎝ FPWM ⎠
Resolución = bits (4.7)
log(2)

La resolución mínima dependerá del predivisor asociado al TMR2, tal y como se muestra en
la tabla 4.1.
TABLA 4.1 Mínimo tiempo del duty cycle en función del valor del predivisor.
Valor del Mínima resolución
T2CKPS1:T2CHPS0
Predivisor (en tiempo)
1 00 TOSC
4 01 TCY
16 1x 4 TCY

Como ejemplo se realiza el cálculo del periodo de una señal PWM, el Duty Cycle, y su
resolución.



Se desea un PWM con una frecuencia de 78.125 KHz, siendo FOSC= 20 MHz y el
predivisor del TMR2=1.

= [(PR 2) + 1]• 4 •
1 1
• •1 => PR2 = 63. (4.8)
78.125 KHz 20 • 10 6 s

(
log 20 • 10
6
)
78.125 • 10 3 = 8 bits
• Resolución Máxima = (4.9)
log(2 )
Para cualquier valor mayor de 255 se producirá un Duty Cycle del 100%.
Para terminar con este modo de operación se describen los pasos a seguir para configurar un
PWM.

Estos son:
1. Establecer el periodo PWM escribiendo el registro PR2.
2. Establecer el Duty Cycle escribiendo los bits DCxB9:DCxB0.
3. Configurar CCPx como salida.
4. Establecer el predivisor del TMR2 y habilitarlo escribiendo en T2CON.
5. Configurar el módulo CCP para la operación en modo PWM.

4.7 Módulo de Tensión de Referencia.

Este módulo proporciona una tensión seleccionable que se obtiene mediante el uso de 16
resistencias en serie. En la figura 4.26 se ve el hardware de este módulo.



Figura 4.26 Diagrama de bloques de módulo de tensión de referencia.

Los distintos valores que pueden obtener, en función de los bits VR3:VR0 (VRCON<3:0>) y
VRR (VRCON<5>), con una alimentación de 5V son los indicados en la tabla 4.2.

TABLA 4.2 Voltajes de referencia típicos con VDD = 5.0 V
VREF
VR3:VR0
VRR = 1 VRR = 0
0000 0.00 V 1.25 V
0001 0.21 V 1.41 V
0010 0.42 V 1.56 V
0011 0.63 V 1.72 V
0100 0.83 V 1.88 V
0101 1.04 V 2.03 V
0110 1.25 V 2.19 V
0111 1.46 V 2.34 V
1000 1.67 V 2.50 V
1001 1.88 V 2.66 V
1010 2.08 V 2.81 V
1011 2.29 V 2.97 V
1100 2.50 V 3.13 V
1101 2.71 V 3.28 V
1110 2.92 V 3.44 V
1111 3.13 V 3.59 V

El registro de control de este módulo es el registro VRCON que consta de los siguientes bits:
R/W-0 R/W-0 R/W-0 U-0 R/W-0 R/W-0 R/W-0 R/W-0



VREN VROE VRR -- VR3 VR2 VR1 VR0
bit 7 bit 0
bit 7 VREN: Habilitación del módulo VREF.
1 = El módulo VREF está conectado.
0 = El módulo VREF está desconectado.
bit 6 VROE: Activación de la salida del módulo VREF.
1 = VREF está conectado internamente con el módulo de comparación.
También está conectado el pin de salida de VREF.
0 = Tanto el comparador como el pin de salida están desconectados.
bit 5 VRR: Selección del rango de VREF.
1 = De 0V a 0.66 VDD, con un paso de VDD/24.
0 = De 0.25 VDD a 0.75 VDD, con un paso de VDD/32.
bit 3:0 VR3:VR0: Selección del valor de VREF .
Cuando VRR = 1:
VREF = (VR<3:0>/24) · VDD
Cuando VRR = 0:
VREF = ¼ · VDD + (VR<3:0>/32) · VDD

Como se puede ver, no se pueden obtener todo el rango de tensiones desde VDD hasta VSS.
Hay que tener en cuenta los consumos de potencia al habilitar el pin de salida de VREF.
Además también puede utilizarse como salida del convertidor D/A con una capacidad
asociada. Debido a ésta capacidad, la tensión de referencia del módulo debe ser utilizada
mediante un buffer como se muestra en la figura 4.27.

Figura 4.27 Ejemplo de buffer de salida del módulo VREF.

4.8 Módulo Comparador Analógico.



Éste módulo contiene dos comparadores analógicos, cuyas entradas están multiplexadas con
pines E/S. El registro que se utiliza para su configuración es el registro CMCON, que se
describe a continuación:

R-0 R-0 U-0 U-0 R/W-0 R/W-0 R/W-0 R/W-0
C2OUT C1OUT -- -- CIS CM2 CM1 CM0
bit 7 bit 0
bit 7 C2OUT: Bit indicador de la salida del comparador 2.
1 = C2 VIN + > C2 VIN –
0 = C2 VIN + < C2 VIN –
bit 6 C1OUT: Bit indicador de la salida del comparador 1.
1 = C1 VIN + > C1 VIN -
0 = C1 VIN + < C1 VIN -
bits 5:4 Bits no implementados: Se leen como ‘0’.
bit 3 CIS: Selección de la entrada del comparador.
Cuando CM2:CM0 = 001:
1 = C1 VIN – se conecta a AN3.
Cuando CM2:CM0 = 010:
C2 VIN – se conecta a AN2.
C2 VIN – se conecta a AN1.
bits 3:0 CM2:CM0: Selección del modo del comparador.
Ver figura 4.28.



Figura 4.28 Modos de operación del comparador.

En la figura 4.29 se muestra la relación entre las entradas analógicas y la salida digital de un
comparador. Como se puede ver cuando la entrada analógica VIN + es menor que VIN –, la
salida del comparador está a nivel bajo. En caso contrario la salida está en nivel alto. Las



áreas sombreadas de la salida del comparador representan una incertidumbre, debida al offset
del operacional y al tiempo de respuesta.

Figura 4.29 Comparador simple.

La señal de referencia puede ser tanto externa como interna. En el primer caso hay que tener
en cuenta que esta señal externa debe estar entre VDD y VSS. También se puede utilizar una
señal de referencia interna cuando CM2:CM0 = 010, usando la salida del módulo de tensión
de referencia.

Las salidas del comparador se leen en el registro CMCON<7:6>, estando además
multiplexadas hacia los puertos E/S si CM2:CM0 = 110. La figura 4.30 muestra el diagrama
de bloques de la salida del comparador.

Este módulo puede generar interrupciones activando el flag CMIF (PIR), cuando su salida
cambie con respecto al último valor almacenado en CMCON. Para que se produzca la
interrupción debe estar habilitada por el bit CMIE (PIE), y estar también activados los bits
GIE y PEIE.

El flag CMIF puede borrarse de las siguientes formas:
• Por software.
• Realizando una lectura o escritura sobre el registro CMCON.



Esta interrupción se puede utilizar para despertar al procesador del modo SLEEP, ya que el
comparador sigue funcionando. Para minimizar la potencia que se consume en este modo,
antes de entrar en él, el comprador se debe configurar en modo CM2:CM0 = 111.

Figura 4.30 Diagrama de bloques de la salida del comparador.

4.9 Convertidor A/D.

Este convertidor permite la conversión de hasta 8 entradas analógicas. El convertidor (figura
4.31) es de ocho bits y convierte por aproximaciones sucesivas. La señal de referencia para el
convertidor puede ser VDD o el valor leído a través de la patilla AN3/VREF.

Tiene la característica especial de que puede funcionar en modo de reposo.



Figura 4.31 Diagrama de bloques del convertidor A/D de 8 bits.

Los registros asociados al convertidor son:
• ADCON0: Registro de control 0: Controlan la operación A/D del módulo.
• ADCON1: Registro de control 1: Configura las funciones de los pines de los
puertos.
• ADRES: Resultado de la conversión.

A continuación se realiza la descripción de cada uno de ellos.

El registro ADCON0 consta de los siguientes bits:

ADCS1 ADCS0 CHS2 CHS1 CHS0 GO/ DONE Reservado ADON
bit 7 bit 0



bits 7:6 ADCS1:ADCS0: Bits de selección del reloj para la conversión A/D.
00 = FOSC/2.
01 = FOSC/8.
10 = FOSC/32.
11 = FRC (Reloj del oscilador interno RC).
bits 5:3 CHS2:CHS0: Bits de selección del canal.
000 = Canal 0, (AN0).
001 = Canal 1, (AN1).
000 = Canal 2, (AN2).
000 = Canal 3, (AN3).
000 = Canal 4, (AN4).
000 = Canal 5, (AN5).
000 = Canal 6, (AN6).
000 = Canal 7, (AN7).
bit 2 GO/ DONE : Bits de estado de la conversión.
Cuando ADCON = 1
1 = Conversión en proceso (poner a ‘1’ para iniciar una conversión).
0 = La conversión ha finalizado.
bit 1 Reservado: Siempre se mantiene a cero.
bit 0 ADON: Activación del conversor A/D.
1 = El comparador está activado.
0 =El comparador no está activado.

En el caso del registro ADCON1 los bits que lo componen son:

U-0 U-0 U-0 U-0 U-0 R/W-0 R/W-0 R/W-0
-- -- -- -- -- PCFG2 PCFG1 PCF0
bit 7 bit 0

bits 7:3 Bits no implementados: Se leen como ‘0’.
bit 2:0 PCFG2:PCFG0: Bit de configuración de los pines del puerto.
PCFG2:PCFG0 AN7 AN6 AN5 AN4 AN3 AN2 AN1 AN0
000 A A A A A A A A
001 A A A A VREF A A A
010 D D D A A A A A
011 D D A A VREF A A A
100 D D D D A D A A
101 D D D D VREF D A A
11x D D D D D D D D
A = Entrada analógica. D = E/S digital.



Nota: Cuando AN3 está seleccionada como VREF, la tensión de referencia es la que hay en el pin
AN3. Cuando AN3 está seleccionada como entrada analógica (A), la tensión de referencia para
el conversor A/D es la VDD del dispositivo.

Los pasos a seguir para realizar una conversión A/D son :
1. Configurar módulo A/D:
a. Configuración de pines analógicos/ Tensión de referencia/ E/S digitales
(ADCON1).
b. Selección de la entrada A/D (ADCON0).
c. Selección de reloj para la conversión A/D (ADCON0).
d. Habilitar módulo A/D (ADON (ADCON0<0>)
2. Configurar las interrupciones (si se quiere):
a. ADIF =0
b. GIE = PEIE = ADIE = 1
3. Esperar el tiempo de adquisición.
4. Comenzar la conversión poniendo a ‘1’ el bit GO/ DONE (ADCON0<2>).
5. Esperar a que termine la conversión. Puede ser de dos formas:
a. Leyendo constantemente el bit GO/ DONE hasta que se ponga a ‘0’,
indicando el fin de la conversión.
b. Esperando a que se produzca la interrupción.
6. Leer registro de conversión ADRES y borrar en flag ADIF si es necesario.
7. Para la siguiente conversión se salta a los puntos 1, 2 ó 3 en función de lo que se
necesite. El tiempo de conversión por bit se define como TAD. Un mínimo de 2TAD
son necesarios antes de la conversión.

Para la conversión existen ciertos requerimientos de tiempos:
• Tiempo de adquisición (TACQ): Es el tiempo que tarda en cargarse el condensador
de retención con la tensión de la salida. Esta carga depende de varios factores,
como pueden ser las impedancias asociadas a la fuente de tensión y a los
interruptores de muestreo,. Se calcula así:
TACQ = TAMP + TC + TCOFF



Siendo TAMP el tiempo de establecimiento del amplificador, TC el tiempo de carga
del condensador y TCOFF el coeficiente de temperatura.
El tiempo de adquisición es del orden de 11µs.
• Tiempo de conversión por bit (TAD): Para convertir 8 bits se requiere un tiempo de
9.5TAD. Por otro lado, el TAD va a depender de la fuente de reloj que se seleccione
para la conversión. Para una correcta conversión A/D, el reloj debe seleccionarse
para asegurar un tiempo TAD de 1,6 µs. En la tabla 4.3 se muestran las distintas
fuentes que se pueden seleccionar junto con el TAD asociado a cada una de ellas.

TABLA 4.3 TAD frente a la frecuencia de operación del dispositivo.
Fuente de reloj Frecuencia del dispositivo
Operación ADCS1:ADCS0 20MHz 5MHz 1.25MHz 333.33kHz
(2) (2)
2TOSC 00 100 ns 400 ns 1.6 µs 6 µs
8TOSC 01 400 ns(2) 1.6 µs 6.4 µs 24 µs(3)
32TOSC 10 1.6 µs 6.4 µs 25.6 µs(3) 96 µs(3)
RC 11 2-6µs(1,4) 2-6µs(1,4) 2-6µs(1,4) 2-6µs(1)
Nota 1: El TAD típico de una fuente RC es de 4µs.
2: Estos valores violan el mínimo tiempo requerido de TAD.
3: Para conversiones más rápidas se recomienda utilizar otra fuente de reloj.
4: Para dispositivos de frecuencias superiores a 1MHz, el dispositivo debe de estar en modo
SLEEP para la conversión completa, o la precisión del convertidor A/D puede estar fuera de
las especificaciones.

El tiempo necesario para la conversión también depende de la resolución con que se quiera
realizar dicha conversión. De este modo:
Tiempo de conversión = TAD + N · TAD + (10 – N) (2TOSC), (4.10)
siendo N el número de bits a convertir. Este tiempo de conversión se puede forzar violando
los requerimientos de TAD.

En la figura 4.32 se muestra la secuencia de la conversión A/D.



Figura 4.32 Secuencia de conversión A/D.

La función de transferencia ideal del convertidor A/D es aquella cuya primera transición
ocurre cuando la tensión analógica de entrada es 1 unidad del bit menos significativo del
resultado (VREF/256) (figura 4.33).

Figura 4.33 Función de transferencia A/D.



Para la conversión, los TRIS asociados tienen que configurase como entradas. Además
Si el módulo CCPx está configurado en modo de comparación con trigger interno, éste
disparará la conversión A/D.

4.10 Módulos de comunicación serie.

En los PIC de la gama Media existen los módulos fundamentales para la comunicación serie:
• Puerto serie síncrono (SSP).
• Receptor transmisor serie síncrono-asíncrono universal (USART).

4.10.1 Puerto Serie Síncrono (SSP).

El módulo SSP es un interface serie de comunicación muy útil para la comunicación con otros
periféricos o microcontroladores. Existen dos formas de operación de éste periférico:
• Interface serie de periféricos (SPI).
• Inter-Integrated Circuit (I2C).

Los registros de control asociados a este módulo son:
• El registro SSPSTAT: Registro de estado del puerto serie síncrono.
R/W-0 R/W-0 R-0 R-0 R-0 R-0 R-0 R-0
SMP CKE D/ A P S R/ W UA BF
bit 7 bit 0
bit 7 SMP: Fase de muestreo de los datos de entrada.
SPI en modo maestro:
1 = El dato se muestrea al final de ciclo.
0 = El dato se muestrea en el medio del ciclo,
SPI en modo esclavo:
SMP debe ponerse a ‘0’ cuando se trabaje en modo esclavo.
bit 6 CKE: Selección de flanco de reloj en modo SPI.
CPK =0 (SSPCON<4>).
1 = El dato se transmite en el flanco de subida de CKS.
0 = El dato se transmite en el flanco de bajada de CKS.
CKP =1 (SSPCON<4>).
1 = El dato se transmite en el flanco de bajada de CKS.
0 = El dato se transmite en el flanco de subida de CKS.



bit 5 D/ A : Bit de datos/ dirección (sólo en el modo I2C).
1 = Indica que el último byte recibido o transmitido era un dato.
0 = Indica que el último byte recibido o transmitido era una dirección.
bit 4 P: Bit de Stop. (sólo en el modo I2C).
1 = Indica que ha sido detectada una condición de Stop.
0 = No se ha detectado la condición de Stop.
bit 3 S: Bit de Start. (sólo en el modo I2C).
1 = Indica que ha sido detectada una condición de Start.
0 = No se ha detectado la condición de Start.
bit 2 R/ W : Bit de Lectura/ Escritura . (sólo en el modo I2C).
Este bit retiene la información de lectura o escritura después de la
última detección de dirección correcta. Es sólo válido desde la
confirmación de dirección hasta el siguiente bit de start, stop, o no
ACK .
1 = Lectura.
0 = Escritura.
bit 1 UA: Actualización de dirección.
(sólo en el modo I2C de 10 bits de dirección)
1 = Se necesita una actualización de la dirección en el reg. SSPADD.
0 = La dirección no necesita una actualización.
bit 0 BF: Bit de buffer lleno.
Recepción (modos SPI e I2C).
1 = Recepción completada, SSPBUF está lleno.
0 = La recepción no ha finalizado, SSPBUF está vacío.
Transmisión
1 = Transmisión en proceso, SSPBUF lleno.
0 = Transmisión completa, SSPBUF vacío

• El registro SSPCON: Registro de control del puerto serie síncrono.

WCOL SSPOV SSPEN CKP SSPM3 SSPM2 SSPM1 SPM0
bit 7 bit 0

bit 7 WCOL: Bit de colisión.
1 = El registro SSPBUF ha sido escrito mientras se realizaba una
transmisión previa (Se borra por software).
0 = No hay colisión.



bit 6 SSPOV: Bit de overflow. (Se borra por software).
En modo SPI:
1 = Un nuevo dato se ha recibido cuando aún no se ha leído el dato
anterior almacenado en SSPBUF. El dato del registro SSPSR se
pierde y se mantiene el anterior. Sólo se produce overflow en modo
esclavo.
0 = No hay overflow.
En modo I2C:
1 = Un nuevo byte es recibido cuando aún no se ha leído el registro
SSPBUF donde se encuentra el byte anteriormente recibido.
0 = No hay overflow.
bit 5 SSPEN: Bit de habilitación del puerto serie síncrono. En ambos
modos, los pines han de ser correctamente configurados como entradas
o salidas.
En modo SPI:
1 = Habilitación del puerto serie y configuración de los pines SCK,
SDO, SDI y SS como fuente de éste.
0 = Puerto serie deshabilitado y pines configurados como E/S.
En modo I2C:
1 = Habilitación del puerto serie y configuración de los pines SDA y
SCL como fuente de éste.
0 = Puerto serie deshabilitado y pines configurados como E/S.
bit 4 CKP: Bit de selección de la polaridad del reloj.
En modo SPI:
1 = El estado de reposo para el reloj es el nivel alto.
0 = El estado de reposo para el reloj es el nivel bajo.
En modo I2C: (control de liberación de la línea de reloj).
1 = Habilitación del reloj.
0 = Mantiene el reloj en estado bajo.
bits 3:0 SSPM3:SSPM0: Selección del modo del módulo SSP.
0000 = SPI, modo maestro, reloj = FOSC/4.
0011 = SPI, modo maestro, reloj = Salida del TMR2 /2.
0100 = SPI, modo esclavo, reloj = pin SCK, pin SS habilitado.
0101 = SPI, modo esclavo, reloj = pin SCK, pin SS deshabilitado.
Puede usarse como pin de E/S.
0110 = I2C, modo esclavo, dirección de 7 bits.
0111 = I2C, modo esclavo, dirección de 10 bits.
1000 = Reservado.
1001 = Reservado.
1010 = Reservado.
1011 = I2C en modo maestro controlado por firmware (esclavo inactivo)
1100 = Reservado.
1101 = Reservado.



1110 = I2C, modo esclavo, dirección de 7 bits con interrupciones de
start y stop habilitadas.
1111 = I2C, modo esclavo, dirección de 10 bits con interrupciones de
start y stop habilitadas.

4.10.1.1 Modo SPI.

El modo SPI permite la transmisión y recepción serie simultanea (full-duplex) de datos de
ocho bits. Típicamente para la comunicación se utilizan tres pines:
• Salida de datos serie (SDO).
• Entrada de datos serie (SDI).
• Reloj serie (SCK).
Además se puede utilizar un cuarto pin cuando se trabaja en el modo esclavo:
• Selección de esclavo ( SS ).

Al inicializar SPI, es necesario especificar varias opciones a través de los registros
SSPCON<5:0> y SSPSTAT<7:6>. Estos bits permiten obtener las siguientes
especificaciones:
• Modo maestro (SCK actúa como salida).
• Modo esclavo (SCK actúa como entrada).
• Polaridad del reloj (cuando el reloj está parado).
• Flanco de reloj (captura del dato).
• Fase de muestreo de los datos de entrada.
• Selección de la fuente de reloj (sólo en modo maestro).
• Selección del modo esclavo.

El módulo consiste en un registro de desplazamiento para recepción/transmisión (SSPSR) y
un registro que actúa como buffer (SSPBUF).

En SSPSR se desplaza el dato en escritura y lectura enviando primero el bit más significativo.
En el registro SSPBUF se mantiene el dato que fue escrito en SSPSR hasta que el dato



recibido está listo. Una vez recibido, el contenido de SSPSR se carga en SSPBUF, activando
además el bit BF (SSPSTAT<0>), y el flag de interrupción SSPIF (PIR).

En la figura 4.34 se puede ver el diagrama de bloques para este modo.

Figura 4.34 Diagrama de bloques del módulo SSP (Modo SPI).

El hecho de tener doble buffer permite que continúe la recepción de datos sin haber realizado
la lectura del byte recibido. Si se produce una escritura en SSPBUF durante la recepción o
transmisión de un dato, ésta será ignorada y se activará el bit de colisión WCOL
(SSPCON<7>). El dato debe leerse antes de que se escriba el siguiente byte en SSPBUF. Al
leerse este registro se borrará el bit BF (SSPSTAT<0>).



Este módulo deja de funcionar en modo SLEEP, si se trata del maestro, continuando una vez
que ha regresado al modo de funcionamiento normal. En caso de que se trate del esclavo,
puede transmitir y recibir estando en modo de reposo produciendo una interrupción al final de
la operación que lo despertará.

La figura 4.35 muestra la forma habitual de conexión entre dos microcontroladores en una
comunicación serie con un modo de operación SPI.

Figura 4.35 Conexión maestro/esclavo en modo SPI.

4.10.1.2 Modo I2C.

Se trata de un protocolo de comunicaciones mediante un par de hilos trenzados. En modo
estándar se pueden alcanzar transmisiones de 100Kbps, aunque en un modo superior se han
llegado a los 400 Kbps. Los pines usados para la transferencia de datos son SCL, que es la
línea de reloj, y SDA, que es la de datos.



En el módulo SSP funcionando en el modo I2C intervienen cinco registros, los cuales se
describen a continuación:
• Registro de control del módulo SSP (SSPCON): Mediante los bits SSPCON<3:0>,
se realiza la selección de uno de los siguientes modos de operación I2C:
o I2C, modo esclavo, dirección de 7 bits.
o I2C, modo esclavo, dirección de 10 bits.
o I2C, modo multimaestro controlado por firmware, con 7 bits de dirección e
interrupciones en STOP y START.
o I2C, modo multimaestro controlado por firmware, con 10 bits de dirección
e interrupciones en STOP y START.
o I2C, modo maestro controlado por firmware.
Además en este registro, mediante el bit SSPEN, se habilita el puerto serie para
que funcione como tal.
• Registro de estado del módulo SSP (SSPSTAT): Este registro muestra información
sobre el estado de la transferencia. Se incluye la detección de las condiciones de
Start y Stop, especifica si lo que se recibe es un dato o una dirección , si el
próximo byte es para completar la dirección de 10 bits, y si es una transferencia de
lectura o escritura.
• Buffer de transmisión/recepción serie (SSPBUF): Es el registro desde el cual se
leen o escriben los datos a transmitir.
• Registro de desplazamiento (SSPSR): Este registro no es directamente accesible.
Es el que desplaza el dato para transmitirlo hacia el exterior del dispositivo, o
recibirlo de otro. En una transmisión se escribe desde el registro SSPBUF,
mientras que en una recepción carga el dato de SSPSR a SSPBUF.
• Registro de dirección (SSPADD): En este registro se almacena la dirección del
esclavo. En el modo de la dirección de 10 bits, primero se debe cargar el byte alto
(1111 0 A9 A8 0), y después el byte bajo (A7:A0).



La figura 4.36 muestra el diagrama de bloques del módulo SSP funcionando en modo I2C.

Figura 4.36 Diagrama de bloques del módulo SSP (modo I2C).

Como en todos los protocolos, el elemento que transmite es el maestro, y el que recibe el
esclavo. Se permite que existan varios maestros, es lo que se denomina modo multimaestro.
El maestro es el que envía la señal de reloj e inicia la transferencia.

En estado de no transferencia las líneas SDA y SCL están en estado alto. Las condiciones de
Start y Stop (figura 4.37) determinan el comienzo y fin de las transferencias:
• Condición de Start: Transición de alto a bajo en la línea SDA cuando la línea SCL
está en el estado alto.
• Condición de Stop: Transición de bajo a alto en la línea SDA cuando la línea SCL
está en el estado alto.



Figura 4.37 Condiciones de Start y Stop.

Debido a la propia definición de estas condiciones, cuando los datos están siendo
transmitidos, la línea SDA únicamente puede cambiar de estado cuando la línea SCL esté a
nivel bajo.

En este protocolo cada elemento tiene asociada una dirección. Así a la hora de realizar una
transferencia el maestro lo que hace es enviar la dirección del elemento con el que quiere
hablar. El resto de elementos deben estar escuchando para ver si se trata de su dirección.
Además en esta trama se envía un bit para indicar que la operación a realizar es de lectura o
escritura. Existen dos tipos de operaciones entre el maestro y el esclavo:
• Maestro transmite y esclavo recibe.
• Esclavo transmite y maestro recibe.

En ambos casos el maestro es el que envía la señal de reloj. Las líneas SCL de reloj y SDA de
datos tienen que estar en colector abierto para implementar de esta forma una Y-cableada
sobre el bus (Será necesario usar resistencias pull-up externamente).

El máximo número de elementos conectados al bus viene dado por la máxima carga que
permite el bus que es de 400pF así como por la capacidad de direccionamiento.

En modo esclavo SDA y SCL deben configurarse como entradas a través de los registros
TRIS. En caso de que se necesite transmitir el módulo SSP se encargará de sobrescribir el
registro TRIS.



Cuando el módulo SSP reciba un dato o una dirección válida, envía automáticamente un bit
de reconocimiento ( ACK ) y carga el registro SSPBUF con el valor del registro SPPSR. En
caso de que el maestro no reciba la señal de ACK después de haber enviado un byte, éste
aborta la transmisión y genera la condición de Stop.

Existen dos condiciones en las cuales no se genera el bit ACK :
a) El bit BF (SSPSTAT<0>) =1 antes de la recepción
del dato actual.
b) El bit SSPOV (SSPCON<6>) =1 antes de la
recepción del dato actual.

Si el maestro es el que recibe los bytes, éste genera un bit ACK por cada byte recibido,
excepto para el último. Cuando el esclavo detecta que no ha recibido el bit de reconocimiento,
deja la línea SDA libre para que el maestro pueda generar la condición de Stop.

Una vez que el módulo SSP está habilitado, se espera a la aparición del bit de Start. Al
detectarse, se empiezan a muestrear los datos de la línea SDA en cada flanco de subida de
SCL, introduciéndolos en el registro SSPSR, que una vez lleno se comparará con el registro
SSPADD en el flanco de bajada del octavo pulso. Si ambas direcciones coinciden, BF y
SSPOV se pondrán a cero, y se sucederán los siguientes eventos:
a) El valor del registro SSPSR será cargado en SSPBUF en el flanco de bajada del
octavo pulso de SCL.
b) El bit de buffer lleno BF se pondrá a ‘1’ en el flanco de bajada del octavo pulso de
SCL.
c) Se genera el bit de reconocimiento ACK .
d) El flag de interrupción SSPIF se activará (produciendo una interrupción si ésta está
habilitada) en el flanco de bajada del noveno pulso de SCL.

En el caso de que las direcciones sean de 10 bits, es necesario recibir dos bytes. El primer
byte (11110 A9 A8 0) ha de ser cargado sobre el registro SSPADD. Los cinco bits más



significativos indican que se trata de un direccionamiento de 10 bits. Los bits A9 y A8 son los
dos bits más significativos de la dirección del esclavo, y por último se envía el bit R/ W . La
secuencia que se sigue es al siguiente:
a) Se recibe el byte alto de la dirección. Los bits SSPIF, BF y UA se ponen a ‘1’.
b) Se actualiza SSPADD con el byte bajo de la dirección (A7:A0) y se borra el bit
UA al realizarse esta escritura.
c) Se lee SSPBUF (BF=0) y se borra el flag SSPIF por software.
d) Se recibe el segundo byte de la dirección. Los bits SSPIF, BF y UA se ponen a ‘1’.
e) Se actualiza SSPADD con el byte alto de la dirección, con lo que se borra UA.
f) Se lee SSPBUF (BF=0) y se borra el flag SSPIF por software.
g) Se recibe la condición de Start repetida.
h) Se recibe de nuevo la parte alta de la dirección. Los bits SSPIF, BF y UA se ponen
a ‘1’.
i) Se lee SSPBUF (BF=0) y se borra el flag SSPIF por software.

En una operación de recepción, cuando el bit R/ W del byte de dirección esté a cero, y ocurra
una validación de dirección, el bit R/ W del registro SSPSTAT se pondrá a cero. Las figuras
4.38 y 4.39 muestran las señales de una recepción con el protocolo I2C.

Figura 4.38 Secuencia de señales en una recepción I2C. (7 bits de dirección).



Figura 4.39 Secuencia de señales en una recepción I2C. (10 bits de dirección).

En la transmisión, cuando el bit R/ W del byte de dirección esté a uno, y ocurra una validación
de dirección, el bit R/ W del registro SSPSTAT se pondrá a uno. El bit de reconocimiento
ACK será enviado en el noveno pulso, y la línea SCL se mantendrá a nivel bajo. El dato a
transmitir debe ser cargado en el registro SSPBUF, de donde se cargará en SSPSR. Entonces
el pin SCL se habilitará poniendo a ‘1’ el bit CKP (SSPCON<4>). Las figuras 4.40 y 4.41
muestran las señales de una transmisión con el protocolo I2C.

Figura 4.40 Secuencia de señales de una transmisión en I2C. (7 bits de dirección).



Figura 4.41 Secuencia de señales de una transmisión en I2C (10 bits de dirección).

El modo de operación como maestro se controla por software mediante interrupciones. Estas
fuentes de interrupción para el control del modo maestro son:
• Condición de Start.
• Condición de Stop.
• Por cada byte recibido o transmitido.

Este protocolo también permite que existan varios maestros en el sistema. Cuando varios
maestros intentan acceder al bus, es necesario un protocolo de arbitraje y una sincronización
del reloj.

El arbitraje se realiza en la línea SDA cuando la línea SCL está en estado alto. Cada maestro
debe chequear constantemente las líneas SDA y SCL. Aquel que transmita un ‘1’ frente al que
transmita un ‘0’ pierde el bus, por lo que tendría preferencia el maestro que envíe la dirección
más baja. En caso de que dos maestros se comuniquen con el mismo elemento, se quedaría
con el bus aquel que mande el dato de menor valor. Un ejemplo de arbitraje entre dos
maestros se muestra en la figura 4.42.



Figura 4.42 Arbitraje entre dos maestros.

La sincronización del reloj se realiza mediante una Y-cableada de las líneas SCL de todos los
maestros.

Sólo se puede hacer uso del bus cuando el bit P (SSPSTAT<4>) está a’1’ o si el bus está en
reposo, es decir S (SSPSTAT<3>) = P (SSPSTAT<4>) = 0.

Para terminar, mencionar que este módulo puede estar recibiendo datos en modo SLEEP y
despertarse mediante la interrupción que indica la transmisión completa del byte. Un RESET
en el sistema deshabilitaría el módulo SSP.

4.10.2 USART.

La USART (Transmisor – Receptor Serie Síncrono – Asíncrono Universal), también conocido
como el interface de comunicación serie (SCI), es el otro de los módulos de comunicación
serie que poseen los PIC. Puede configurarse para que trabaje en modo full – duplex
asíncrono para comunicarse con un PC o terminal y en modo half – duplex para periféricos.



Tiene tres modos de trabajo:
• Asíncrono (full – duplex).
• Maestro síncrono (half duplex).
• Esclavo síncrono (half duplex).

Los registros asociados a este módulo son:
• TXSTA: Registro de control y estado de la transmisión.

R/W-0 R/W-0 R/W-0 R/W-0 U-0 R/W-0 R-1 R/W-0
CSRC TX9 TXEN SYNC -- BRGH TRMT TX9D
bit 7 bit 0

bit 7 CSRC: Selección de la fuente de reloj.
Modo asíncrono:
No se tiene en cuenta.
Modo síncrono:
1 = Modo maestro (reloj generado internamente por BRG).
0 = Modo esclavo ( fuente de reloj externa).
bit 6 TX9: Habilitación de la transmisión de 9 bits.
1 = Transmisión de 9 bits.
0 = Transmisión de 8 bits.
bit 5 TXEN: Bit de habilitación del transmisor.
1 = Transmisor activado.
0 = Transmisor desactivado.
bit 4 SYNC: Selección del modo de la USART.
1 = Modo síncrono.
0 = Modo asíncrono.
bit 2 BRGH: Selección de baudios de alta velocidad.
Modo asíncrono:
1 = Alta velocidad.
0 = Baja velocidad.
Modo Síncrono:
bit 1 TRMT: Estado del registro de desplazamiento TSR.
1 = TSR lleno.
0 = TSR vacío.
bit 0 TX9D: 9º bit de datos en la transmisión. Puede ser un bit de paridad.



• RCSTA: Registro de control y estado de recepción.

R/W-0 R/W-0 R/W-0 R/W-0 U-0 R-0 R-0 R-0
SPEN RX9 SREN CREN -- FERR OERR RX9D
bit 7 bit 0

bit 7 SPEN: Habilitación del puerto serie.
1 = Puerto serie habilitado (configura los pines RX/DT y TX/CK como
pines del puerto serie).
0 = Puerto serie deshabilitado.
bit 6 RX9: Habilitación de la recepción de 9 bits.
1 = Recepción de 9 bits.
0 = Recepción de 8 bits.
bit 5 SREN: Activación de recepción simple
Modo asíncrono:
No se tiene en cuenta.
Modo síncrono:
1 = Activa la recepción.
0 = Desactiva la recepción.
Este bit se pone a ‘0’ después de que la recepción ha sido completada.
bit 4 CREN: Activación de recepción continua.
Modo asíncrono:
1 = Activada la recepción.
0 = Desactivada la recepción.
Modo síncrono:
1 = Activa la recepción continua
0 = Desactiva la recepción continua.
bit 2 FERR: Error de framing.
1 = Se ha producido error (se actualiza leyendo el registro RCREG y
recibiendo el siguiente dato válido).
0 = No hay error.
bit 1 OERR: Error de overrun.
1 = Se ha producido error (se borra borrando CREN).
0 = No hay error.
bit 0 RX9D: 9º bit de datos en la recepción. Puede ser un bit de paridad.

• SPBRG: Registro de selección de baudios.



Este último registro controla el periodo de funcionamiento del generador de baudios. El
generador de baudios es un registro de ocho bits llamado BRG. Para saber que valor hay que
cargar en el registro SPBRG hay que usar las siguientes expresiones:
• Modo asíncrono (SYNC = 1).
o Baja velocidad (BRGH = 0);
FOSC
Baudios = (4.11)
64 • (x + 1)
o Alta velocidad (BRGH = 1);
FOSC
Baudios = (4.12)
16 • (x + 1)
• Modo síncrono (SYNC = 0).
o Baja velocidad (BRGH = 0);
FOSC
Baudios = (4.13)
4 • (x + 1)
o Alta velocidad (BRGH = 1);
No implementado.

Así por ejemplo si se quieren obtener 9600 baudios, con una FOSC de 16MHz, en modo
asíncrono, a baja velocidad, el valor que se deberá cargar en el registro SPBRG se calcula de
la siguiente forma:
16 • 10 6
9600 = ; (4.14)
64 • (x + 1)
de donde x = 25.042 ≈ 25 con un error del 0.16%.

Normalmente suele ser más ventajoso usar el modo rápido, aún cuando la velocidad sea baja,
ya que la expresión (4.12) reduce el error del generador de baudios el algunos casos. Cuando
se produce una nueva escritura sobre SPBRG, el temporizador BRG se resetea.

4.10.2.1 Modo asíncrono.

En este modo la USART utiliza el formato estándar NRZ (nonreturn–to–zero), que consta de
un bit de start, ocho o nueve bits de datos y un bit de stop. Los datos son transmitidos y
recibidos comenzando por el bit menos significativo. El transmisor y receptor son
funcionalmente independientes pero utilizan el mismo formato y generador de baudios,



pudiendo utilizar este reloj entre x16 o x64, dependiendo del bit BRGH (TXSTA<2>). La
paridad no está implementada por hardware, pero se puede realizar mediante software y
almacenarse como el noveno bit de datos. Este módulo asíncrono permanece inactivo cuando
el sistema se encuentra en modo SLEEP.

El modo asíncrono se selecciona poniendo a cero el bit SYNC (TXSTA<4>).

Transmisión
El registro usado para transmitir es el registro de desplazamiento TSR (figura 4.43), el cual
recibe el dato del registro de lectura/escritura TXREG que se carga mediante software. La
transferencia de TXREG a TSR no se produce hasta que no se transmita el bit de Stop del
carácter anterior. Una vez cargado el registro TSR con el valor de TXREG, este último se
queda vacío y el flag TXIF (PIR) se pone a ‘1’.En el caso de que TXIE, PEIE y GIE estén
activados, se producirá una interrupción. El flag TXIF sólo se puede borrar haciendo una
nueva escritura sobre el registro TXREG.

Figura 4.43 Diagrama de bloques de la USART transmitiendo.

El flag TRMT (TXSTA<1>) indica si el registro TSR está lleno o vacío. Para poder transmitir
el noveno bit se usan los flags TX9 (TXSTA<6>) que habilita la transmisión de este bit y



TX9D (TXSTA<0>). Este bit tiene que ser escrito antes de los ocho bits de datos, ya que una
escritura en el registro TXREG puede producir una escritura inmediata de TSR si este se
encuentra vacío. Los pasos a seguir para la configuración de una transmisión asíncrona son:
1. Inicialización de SPBRG con los baudios que se deseen. Si se quiere
velocidad alta el bit BRGH (TXSTA<2>) se deberá poner a ‘1’.
2. Habilitar el puerto serie asíncrono borrando el bit SYNC (TXSTA<4>) y
poniendo a ‘1’ el bit SPEN (RCSTA<7>).
3. Si se quieren interrupciones se deberán habilitar los bits TXIE, GIE y
PEIE.
4. Si la transmisión va a ser de 9 bits, habrá que poner a ‘1’ el bit TX9
(TXSTA<6>).
5. Habilitación de la transmisión por medio del bit TXEN (TXSTA<5>). Al
hacer esto el bit TXIF se pondrá a ‘1’ ya que TXREG está vacío.
6. En el caso de que se quiera transmitir el noveno bit, se escribe sobre el bit
TX9D (TXSTA<0>).
7. Se carga el byte a transmitir en el registro TXREG, con lo que comienza la
transmisión.

La figura 4.44 muestra un ejemplo de una secuencia de transmisión asíncrona de una USART
en modo maestro.

Figura 4.44 Transmisión asíncrona.



Recepción
El módulo de recepción asíncrono recibe los datos a través del pin RX/DT mediante el
módulo de “recuperación de datos” (figura 4.45). Este bloque no es más que un registro de
desplazamiento de alta velocidad que opera a 16 veces la velocidad en baudios del módulo de
transferencia. Una vez que se tiene seleccionado el modo asíncrono la recepción se habilita a
través del bit CREN (RCSTA<4>).

Figura 4.45 Diagrama de bloques de la USART en recepción asíncrona.

El bloque fundamental de esta recepción es el registro de desplazamiento RSR. Una vez
detectado el bit de Stop que indica el fin de la transferencia, el byte leído en RSR se transfiere
a RCREG, activándose el flag RCIF (PIR) y produciendo una interrupción en el caso de que
RCIE (PIR), GIE y PEIE estén activados. El flag RCIF es un bit de sólo lectura, la forma de
borrarlo es leyendo el registro RCREG, dejándolo vacío. Este último registro es un doble
buffer que permite recibir dos bytes y transferirlos a RCREG y estar recibiendo un tercer byte
en RSR. Cuando se detecta el bit de Stop de este tercer byte, si el registro RCREG está lleno,
se produce un error de overrun y se activa el flag OERR (RCSTA<1>). En este caso la



palabra de RSR se pierde. Este bit se borra poniendo a ‘0’ y luego a ‘1’ el bit CREN
(RCSTA<4>). Otro tipo de error que se puede producir es el error de framing, que consiste en
leer el bit de Stop a nivel bajo. Este error se refleja activando el bit FERR (RCSTA<2>). El
bit FERR y el noveno bit del dato se cargan sobre el registro RCSTA. Esta carga de RX9D y
FERR se produce al realizar la lectura del registro RCREG, por lo que es fundamental leer el
registro RCSTA antes de leer de nuevo RCREG, ya que se perdería esta información. Los
pasos a seguir en una recepción asíncrona son:
1. Inicializar SPBRG con el valor de baudios apropiado. Si se quiere velocidad alta el
bit BRGH (TXSTA<2>) se deberá poner a ‘1’.
2. Habilitar el funcionamiento en modo síncrono borrando el bit SYNC (TXSTA<4>)
y activando SPEN (RCSTA<7>).
3. Si se van ha utilizar interrupciones habrá que habilitarlas activando los bits RCIE,
GIE y PEIE.
4. En caso de querer recibir el noveno bit se pondrá RX9 (RCSTA<6>) a ‘1’.
5. Habilitar la recepción activando el bit CREN (RCSTA<4>).
6. Después de cada carácter recibido el flag RCIF (PIR) se pondrá a ‘1’, activando
una interrupción en caso de que ésta esté habilitada.
7. Leer el registro RCSTA para obtener el noveno bits, si éste está habilitado, y ver si
ha aparecido algún error.
8. Leer los ocho bits restantes mediante la lectura de RCREG.
9. Si se ha producido algún error, borrar el flag a través del bit CREN (RCSTA<4>).

La figura 4.46 muestra un ejemplo de una secuencia de recepción asíncrona.

Figura 4.46 Recepción asíncrona.



4.10.2.2 Modo síncrono.

En el modo síncrono la comunicación es de tipo half-duplex, por lo que la transmisión y la
recepción no pueden realizarse al mismo tiempo. La diferencia sustancial entre el modo
síncrono y el asíncrono es que ahora el reloj es generado por el maestro y el esclavo lo utiliza.
Este reloj se recibe a través de la patilla TX/CK. Para configurar la USART para que trabaje
en modo síncrono hay activar el bit SYNC (TXSTA<4>).

Modo Maestro
Para configurar el modo maestro se pone a ‘1’ el bit SPEN (RCSTA<7>), con lo que se
configura TX/CK y RX/DT como líneas para reloj y datos respectivamente. Además el modo
maestro se configura también mediante la activación del bit CSRC (TXSTA<7>).

Con respecto a la transmisión, no existen diferencias sustanciales con respecto al modo
asíncrono, salvo que ahora el reloj se propaga a los esclavos a través de TX/CK.

Los pasos necesarios para llevar a cabo una transmisión síncrona son:
1. Inicializar el registro SPBRG con el valor apropiado. Para el modo de alta
velocidad será necesario poner a ‘1’ el bit BRGH.
2. Habilitar el puerto serie síncrono en modo maestro poniendo a ‘1’ los bits SYNC,
SPEN y CSRC.
3. Si se desea utilizar interrupciones, habrá que habilitar el bit TXIE.
4. Si se quiere realizar la transmisión del noveno bit activar el bit TX9 (TXSTA<6>).
5. Habilitar la transmisión mediante el bit TXEN.
6. Si se ha seleccionado la transmisión del noveno bit, habrá que cargar el valor de
éste en TX9D.
7. Cargar el dato en el registro TXREG, con lo que se iniciará la transmisión.

En la figura 4.47 se muestra la secuencia de una transmisión síncrona.



Figura 4.47 Transmisión síncrona.

Con respecto a la recepción, una vez que el maestro se ha configurado, se habilita con el flag
SCREN (RCSTA<5>), si está a ‘1’ recibirá un carácter y se pondrá a ‘0’ deshabilitando la
recepción, o mediante la activación del bit CREN (RCSTA<4>) que habilitará la recepción
continua hasta que se ponga a ‘0’. El resto es igual que en la recepción asíncrona. Los pasos a
llevar a cabo en una recepción síncrona son:
1. Inicializar el registro SPBRG con el valor apropiado. Para el modo de alta
velocidad será necesario poner a ‘1’ el bit BRGH.
2. Habilitar el puerto serie síncrono en modo maestro poniendo a ‘1’ los bits SYNC,
SPEN y CSRC.
3. Asegurarse de que los bits CREN y SCREN están a ‘0’.
4. Si se desea utilizar interrupciones, habrá que habilitar el bit RCIE..
5. Si se quiere realizar la recepción del noveno bit activar el bit RX9 (RCSTA<6>).
6. Si se necesita la recepción única se pondrá a ‘1’ en bit SCREN, mientras que para
recepción continua se activará CREN
7. El flag RCIF se activará cuando la recepción se haya completado dando lugar a
una interrupción si esta estuviese activada.
8. Leer el registro RCSTA para obtener el noveno bit y determinar si hubo algún
error en la recepción.
9. Leer la palabra recibida en el registro RCREG.
10. En el caso de que se hubiera producido algún error, desactivarlo poniendo a cero el
bit CREN.



En la figura 4.48 se muestra la secuencia de una recepción síncrona.

Figura 4.48 Recepción síncrona.

Modo esclavo
Este modo difiere del modo maestro en que reloj se recibe por el pin TX/CK, pudiendo
transmitir y recibir en modo de reposo (SLEEP). Para entrar en modo esclavo es necesario
poner a ‘0’ el bit CSRC (TXSTA<7>).

Tanto la transmisión como la recepción es igual que en el modo maestro salvo cuando trabaja
en modo de reposo.
• Transmisión en reposo: Se pueden escribir dos caracteres, uno en TXREG que
pasa a TSR, y otro que quedará en TXREG. Una vez que el segundo carácter pase
a TSR se producirá una interrupción que despertará al sistema.
• Recepción en reposo: Para poder recibir datos el bit CREN ha de estar activado.
Una vez recibido un carácter, éste pasa del registro RSR a RCREG produciendo
una interrupción que saca al sistema del modo de reposo.


Microcontroladores PIC de la Gama Media. 5. Programación con PIC.

Capítulo 5. Programación con PIC.

5.1 Introducción.

Una vez que se ha visto la estructura y las características del funcionamiento de los
microprocesadores PIC de la gama Media, hay que hacer mención a la forma de
programarlos.

A lo largo de este capítulo se tratará el ensamblador de los PIC, MPASM, que es el que
produce el código máquina para poder programar el dispositivo. También se verá algo sobre
el montador de enlaces MPLINK, el cual permite programar un dispositivo a partir de varios
códigos objeto o hacer uso de librerías.

Debido a la gran variedad de situaciones que se pueden dar a la hora de realizar un programa,
se darán una nociones de cómo programar, a partir del juego de instrucciones reducido de los
microcontroladores PIC, estructuras de cierta complejidad, como estructuras iterativas,
condicionales, creación de códigos de condición, etc.

Otro punto de gran utilidad a la hora de programar es la utilización de librerías, ya que
ofrecen multitud de aplicaciones ya programadas.

5.2 Directivas del ensamblador MPASM.

Las directivas son comandos del ensamblador que aparecen en el código fuente, pero que no
son traducidas a código máquina. Éstas son usadas para el control del ensamblador; entradas,
salidas y localización de datos. Muchas de las directivas del ensamblador tienen distintos
nombres y formatos, para ofrecer compatibilidad con ensambladores anteriores de Microchip.



A continuación se muestra la tabla 5.1 con todas las directivas del ensamblador.
TABLA 5.1 Resumen de las directivas.
Directiva Descripción Sintaxis
Especifica las localizaciones inválidas de la
_ _BADRAM _ _badram <expr>
RAM.
Genera código para la selección del banco de
BANKISEL bankisel <etiqueta>
RAM para un direccionamiento indirecto.
BANKSEL Genera código para la selección de banco RAM. banksel <etiqueta>
CBLOCK Define un bloque de constantes. cblock [<expr>]
CODE Comienzo de sección de código ejecutable. [<etiqueta>] code [<dirección>]
_ _CONFIG Especifica los bits de configuración. _ _config <expr>
constant <etiqueta>[=<expr>,...
CONSTANT Declara símbolos constantes.
...,<etiqueta>[=<expr>]
[<etiqueta>]data<expr>[,<expr>,.., expr>]
DATA Crea datos numéricos y textos. [<etiqueta>]data“<cadena_de_texto>”
[,“<cadena_de_texto>”, ...]
[<etiqueta>] db<expr>[,<expr>,...,<expr>]
DB Declara datos de un byte.
[<etiqueta>] db“<texto>”[,“<texto>”,...]
[<etiqueta>] de<expr>[,<expr>,...,<expr>]
DE Define datos EEPROM.
[<etiqueta>] de“<texto>”[,“<texto>”,...]
define <nombre> [<valor>]
#DEFINE Define etiquetas.
define <nombre> [<arg>,...,<arg>]<valor>
[<etiqueta>] dt<expr>[,<expr>,...,<expr>]
DT Define una tabla.
[<etiqueta>] dt“<texto>”[,“<texto>”,...]
[<etiqueta>]dw<expr>[,<expr>,...,<expr>]
DW Declara datos de una palabra.
[<etiqueta>]dw“<texto>”[,“<texto>”,...]
ELSE Comienzo de bloque alternativo a IF. else
END Fin del bloque de programa. end
ENDC Fin de un bloque de definición de constantes. endc
ENDIF Fin de un bloque condicional. endif
ENDM Fin de la definición de una macro. endm
ENDW Fin de un lazo while endw
EQU Define y ensambla constantes. <etiqueta> equ <expr>
ERROR Emisión de un mensaje de error. error “<cadena_de_texto>”
ERRORLEVEL Fija niveles de error. errorlevel 0 | 1 | 2 <+ | -><nummsj>
EXITM Sale de una macro. exitm
EXPAND Expansión de macros. expand
EXTERN Declara una etiqueta externa. extern <etiqueta>[,<etiqueta>]
FILL Ocupa memoria. [<etiqueta>] fill <expr>, <cuenta>
GLOBAL Exporta una etiqueta definida. global <etiqueta> [, <etiqueta>]
IDATA Comienza una sección de datos inicializados. [<nombre>] idata [<dirección>]
_ _IDLOCS Especifica localizaciones ID. _ _idlocs <expr>
Comienza un bloque de ensamblado de código
IF if <expr>
condicional.
IFDEF Ejecuta si el símbolo ha sido definido. ifdef <etiqueta>
IFNDEF Ejecuta si el símbolo no ha sido definido. ifndef <etiqueta>
include <<archivo_include>> |
#INCLUDE Incluye archivos fuente adicionales.
“<archivo_include>”
LIST Listado de opciones. list [<opción_list>, ..., <opción_list>]
LOCAL Declara una variable local de una macro. local <etiqueta> [,<etiqueta>]
MACRO Define una macro. <etiqueta> macro [<arg>, ..., <arg>]
_ _MAXRAM Especifica la dirección máxima de RAM. _ _maxram <expr>



Directiva Descripción Sintaxis
MESSG Crea mensaje definido por el usuario messg “<texto_del_mensaje>”
NOEXPAND Fin de la expansión de macros. noexpand
NOLIST Desactiva las opciones de salida. nolist
ORG Fija el origen del programa. <etiqueta> org <expr>
PAGE Inserta una salida de página. page
Genera el código para la selección de la página
PAGESEL pagesel <etiqueta>
de ROM.
PROCESSOR Indica tipo de procesador. processor <tipo_de_procesador>
RADIX Especifica la base de numeración por defecto. radix <radix_defecto>
RES Reserva memoria. [etiqueta>] res <unidades_de_memoria>
SET Define y ensambla variables. <etiqueta> set <expr>
SPACE Inserta líneas en blanco en el listado. space <expr>
SUBTITLE Especifica el subtítulo del programa. subtitle “<texto_de_subtítulo>”
TITLE Especifica el título del programa. title “<texto_de_título>”
UDATA Comienza una sección de datos no inicializados. [<nombre>] udata [<dirección>]
Comienza una sección de datos no inicializados
UDATA_OVR [<nombre>] udata_ovr [<dirección>]
reutilizables.
Comienza una sección de datos no inicializados
UDATA_SHR [<nombre>] udata_shr [<dirección>]
compartidos.
#UNDEFINE Borra una etiqueta de substitución. #undefine <etiqueta>
variable <etiqueta>[=<expr>, ...,
VARIABLE Declara un símbolo variable.
<etiqueta> [=<expr>]]
WHILE Ejecuta un lazo mientras la condición sea verdad while <expr>

A continuación se muestra una descripción detallada de cada una de ellas:

• _ _BADRAM y _ _MAXRAM1: Ambas directivas juntas marcan los registros que
no están implementados. _ _MAXRAM define la dirección máxima de RAM
válida, iniciando el mapa de RAM, validando todas las direcciones menores que
<expr>. El valor marcado por <expr> debe ser mayor o igual que la máxima
dirección de la página 0 de la memoria RAM y menor que 1000H. _ _BADRAM
define la localización de las direcciones de la RAM que no son válidas. Una
directiva _ _BADRAM debe estar precedida por una _ _MAXRAM. Cada <expr>
usada por _ _BADRAM debe ser menor o igual al valor especificado por la <expr>
de _ _MAXRAM.
_ _ MAXRAM puede ser usada más de una vez, redefiniendo la máxima dirección
válida de RAM y reseteando el mapa entero de RAM.

1
En las directivas que están precedidas por dos guiones bajos _ _, no hay ningún espacio entre ellos, pero en este
documento se incluyen, ya que si no, no se distinguen bien.



La sintaxis de estas directivas es:
_ _maxram <expr>
_ _badram <expr>
Ejemplo:
list p=16c622
_ _maxram H’0BF’
_ _badram H’07’ – H’09’, H’0D’ – H’1E’
_ _badram H’87’ – H’89’, H’8D’, H’8F’ – H’9E’
movwf H’07’ ; Genera un warning de RAM inválida
movwf H’87’ ; Genera un warning de RAM inválida
; y un mensaje de truncamiento
• BANKISEL: Se usa cuando se genera un código objeto. Esta directiva es una
instrucción que genera la selección adecuada del banco para el acceso indirecto
una dirección especificada por una <etiqueta>. Sólo una <etiqueta> puede ser
especificada, y debe ser previamente definida. El linkador generará el código
apropiado para seleccionar el banco.
La sintaxis es:
bankisel <etiqueta>
Ejemplo:
movlw Var1
movwf FSR
bankisel Var1
...
movwf INDF

• BANKSEL: Se usa para generar el código objeto de un programa. Esta directiva
es una instrucción para que el linkador genere el código para ir de banco a banco
designando una <etiqueta>. Sólo puede ser especificada una <etiqueta>, que debe
ser previamente definida.
La sintaxis es la siguiente:
banksel <etiqueta>
Ejemplo:
banksel Var1
movwf Var1



• CBLOCK y ENDC: Sirve para definir una lista de constantes en la memoria de
datos.
cblock [<expr>]
<etiqueta>[:incremento][,<etiqueta>[:<incremento>]]
endc
[<expr>] indica la dirección inicial de la memoria de datos para la primera
etiqueta. En el caso de no ser especificada, se pueden dar dos situaciones:
a) Si anteriormente se ha utilizado esta misma directiva, entonces a la primera
etiqueta se le asigna la dirección inmediatamente superior a la de la última
etiqueta de la directiva CBLOK anterior.
b) En el caso de que sea la primera vez que se utilice, entonces se le asigna la
dirección 0x00.
Todas las etiquetas dentro de la definición de CBLOCK tendrán posiciones de
memoria consecutivas, a no ser que se haya definido [:<incremento>], en cuyo
caso se incrementará la dirección con el valor indicado.
La definición de etiquetas termina cuando el ensamblador se encuentre con la
directiva ENDC.
Ejemplo:
cblock 0x0C ; nombre_1 será
; asignada a la dirección 0x0C
nombre_1, nombre_2 ; nombre_2 a 0E, nombre_3 a 0F
nombre_3, nombre_4 ; y nombre_4 a 10.
endc
• CODE: Se utiliza en la generación de código objeto. Indica el principio de la
sección de un código de programa. Si no se especifica la <etiqueta>, la sección se
nombra como code. La dirección donde empieza la sección de programa es la
dirección especificada, siendo cero si no se indica.
La sintaxis es:
[<etiqueta>] code [<dirección de ROM>]
Ejemplo:
RESET code H’01FF’
goto INICIO



• _ _CONFIG: Pone los bits de configuración del microprocesador al valor indicado
por <expr>. Hay que referirse a las hojas de características de los
microcontroladores PIC para la descripción de los bits de configuración de cada
procesador.
Antes del uso de esta directiva, el procesador debe de ser declarado a través de la
línea de comandos, con la directiva LIST o PROCESOR. Si estas directivas son
usadas con la familia PIC17CXX, el formato de salida del archivo hex debe estar
fijado a INHX32 mediante una directiva LIST.
La sintaxis de esta directiva es:
_ _config <expr>
Ejemplo:
list p=17c42, f=INHX32
_ _config H’FFFF’ ; Bits de configuración por defecto.
• CONSTANT y VARIABLE: Sirve para definir símbolos que pueden ser usados
en expresiones de MPASM. La diferencia entre usar una u otra, es que con
CONSTANT no se puede modificar su valor una vez asignado. Además al definir
variables no es necesario iniciarlas.
constant <etiqueta>=<expr>[,<etiqueta>=<expr>]
variable <etiqueta>[=<expr>][,<etiqueta>[=<expr>]]
Ejemplo:
variable RECLONG=64 ; Establece el valor por defecto de RECLONG.
constant BUFLONG=512 ; Inicializa BUFLONG.
constant MAXMEM=RECLONG+BUFLONG ; Calcula MAXMEM
• DATA: Inicializa con datos una o más palabras de la memoria de programa. Estos
datos pueden ser constantes, etiquetas o expresiones de alguna de las anteriores. El
dato puede consistir también en una cadena de caracteres en código ASCII,
<cadena_de_texto>, encerrado en comillas simples para un solo carácter o dobles
comillas para una cadena. Los elementos de un solo carácter se guardan en el byte
bajo de la palabra, mientras que las cadenas de caracteres son guardas de dos en
dos en cada palabra, con el primer carácter en el byte más significativo. Si el



número de caracteres es impar, el último byte es cero. Cuando se genera el código
objeto, esta directiva también puede utilizarse para inicializar valores de datos.
La sintaxis de esta directiva es:
[<etiqueta>] data <expr>[,<expr>, ..., <expr>]
[<etiqueta>] data “<cadena_de_texto>”[, “<cadena_de_texto>”, ...]
Ejemplo:
data etiqueta_reubicablel+10 ; constantes
data 1,2,etiqueta_ext l ; constantes, externas
data “testeando 1,2,3” ; cadena de texto
data ‘N’ ; carácter simple
data inicio_de_programa ; etiqueta reubicable
• DB: Reserva palabras en la memoria de programa con valores de ocho bits. Para
expresiones múltiples se guardan en bytes consecutivos hasta el final de la
expresión. Si son un número impar de expresiones, el último byte será cero.
Cuando se genera el código objeto, esta directiva también se puede utilizar para
inicializar el valor de los datos.
Su sintaxis es:
[<etiqueta>] db <expr>[,<expr>, ..., <expr>]
Ejemplo:
db ‘t’, 0x0f, ‘e’, 0x0f, ‘s’, 0x0f, ‘t’, ‘n’
• DE: Reserva palabras en memoria con datos de ocho bits. Cada <expr> debe
evaluarse con un valor de ocho bits. Los bits altos de la palabra son ceros. Cada
carácter en una cadena de caracteres se guarda en una palabra distinta.
Aunque se diseñó originalmente para inicializar datos EEPROM en los PIC16C8X,
esta directiva puede utilizarse para cualquier localización y en cualquier
procesador.
Su sintaxis es:
[<etiqueta>] de <expr>[,<expr>, ..., <expr>]
Ejemplo:
org H’2100’ ; Inicializar datos EEPROM.
de “Mi Programa, v1.0”, 0

• #DEFINE: Esta directiva sustituye un nombre por un valor. Donde quiera que
aparezca <nombre> en el código ensamblador, será sustituido por <valor>.



Si no se añade el valor al que sustituir simplemente se define un <nombre>,
pudiéndolo testear usando la directiva IFDEF.
Su sintaxis es:
#define <nombre> [<valor>]
Ejemplo:
#define longitud 20
#define control 0x19,7
#define posición (X,Y,Z) (Y-(2 * Z +X))
.
.
.
test dw posición (1, longitud, 512)
bsf control ; pone a ‘1’ el bit 7 en f19
• DT: Genera una serie de instrucciones RETLW, una por cada <expr>. Éstas deben
ser un valor de ocho bits. En una cadena de caracteres, cada uno se guarda en su
propia instrucción RETLW.
Su sintaxis es:
[<etiqueta>] dt <expr> [,<expr>, ..., <expr>]
Ejemplo:
dt “Mensaje”, 0
dt PrimerValor, SegundoValor, UltimoValor
• DW: Reserva palabras de la memoria de programa para datos, inicializando estos
espacios a valores específicos. Los datos son guardados en posiciones de memoria
consecutivas, incrementando el contador en uno. Las expresiones pueden ser
cadenas de literales y se guardan como se describe en la directiva DATA.
Sintaxis:
[<etiqueta>] dw <expr>[,<expr>, ..., <expr>]
Ejemplo:
dw 39, “diagnostico 39”, (d_list*2+d_offset)
dw diagbase-1

• ELSE: Se usa junto con la directiva IF para proporcionar un camino alternativo a
la ensamblación si se evalúa el IF como falso.
Sintaxis:
else



Ejemplo:
velocidad macro kmh
if kmh < 50
dw despacio
else
dw rapido
endif
endm

• END: Indica el fin del programa fuente. Esta directiva debe ponerse siempre al
final del código de programa a ensamblar.
• ENDIF: Esta directiva marca el final de un bloque condicional de ensamblador.

• ENDM: Termina una definición de una macro iniciada con MACRO.
Sintaxis:
endm
Ejemplo:
tabla macro arg1, arg2 ;
dw arg1, 0 ;
endm
• EQU y SET: Define y ensambla variables y constantes.
La sintaxis es:
<etiqueta> set <expr>
<etiqueta> equ <expr>
La diferencia entre ambas es que set puede ser redefinida las veces que se quieran,
sin embargo, con equ, una vez definida no se puede modificar su valor.
• ERROR: La <cadena_de_texto> se imprime en el mismo formato que cualquier
mensaje de error del MPASM. La <cadena_de_texto> puede ser desde uno hasta
80 caracteres.
Sintaxis:
error “<cadena_de_texto>
Ejemplo:
error_verificación macro arg1
if arg1>= 55 ; si arg está fuera del rango.
error “error_verificación argumento fuera de rango”
endif



• ERRORLEVEL: Fija el tipo de mensajes que aparecen en el listado del programa
y en el archivo de errores.
Sintaxis:
errorlevel 0|1|2|<+|-><nummsj>
La tabla 5.2 indica como afecta cada una de las opciones que se pueden dar en el
uso de esta directiva.
TABLA 5.2 Opciones de la directiva ERRORLEVEL.
Selección Afecta
0 Mensajes, peligro, y errores de impresión.
1 Peligros y errores de impresión.
2 Errores de impresión.
-<nummsj> Inhabilita la impresión de mensaje <nummsj>.
+<nummsj> Habilita la impresión del mensaje <nummsj>.

Los mensajes de error no pueden ser deshabilitados. La selección de 0, 1, ó 2 anula
la habilitación o deshabilitación individual de los mensajes.
Ejemplo:
errorlevel 1, -202

• EXITM: Fuerza el retorno inmediato de una macro durante el ensamblado. El
efecto es el mismo que si se encontrara con la directiva ENDM.
Sintaxis:
exitm
Ejemplo:
test macro registro
if registro = = 1 ; comprobación de registro válido.
exitm
else
error “asignación de registro incorrecta”
endif
endm
• EXPAND: Extiende todas las macros en el registro del listado, es decir incluye en
el listado la secuencia de instrucciones de la macro. Esta directiva es
aproximadamente equivalente a la opción /m en MPASM, pero puede estar
limitada en su alcance por una posterior directiva NOEXPAND.
• EXTERN: Declara nombre de símbolos que pueden ser usados en el módulo
actual, pero que son definidos como global en módulos diferentes. La declaración



EXTERN debe ser incluida antes de que la <etiqueta> sea usada. Al menos una
etiqueta debe ser especificada en la línea.
Sintaxis:
extern <etiqueta>[,<etiqueta>]
Ejemplo:
extern Funcion
...
call Funcion

• FILL: Genera <cuenta> ocurrencias de la palabra o byte de programa <expr>. Si
está limitada por paréntesis, <expr> puede ser una instrucción de ensamblador.
Sintaxis:
[<etiqueta>] fill <expr>, <cuenta>
Ejemplo:
fill 0x1009, 5 ; ocupa con una constante.
fill (GOTO VECTOR_RESET), SIGUIENTE_BLOQUE-$
• GLOBAL: Se usa en la generación de código objeto. Declara nombres de
símbolos que son definidos en el módulo actual, estando disponibles en otros
módulos. La declaración GLOBAL debe de ser después de que la <etiqueta> sea
definida. Al menos una etiqueta debe de ser especificada en la línea.
Sintaxis:
global <etiqueta> [, <etiqueta>]
Ejemplo:
udata
Var1 res 1
Var2 res 1
global Var1, Var2
code
SumaTres
global SumaTres
addlw 3
return

• IDATA: Se usa en la generación de código objeto. Declara el comienzo de una
sección de datos inicializados. Si no se especifica ninguna <etiqueta> la sección es
nombrada idata. La dirección de comienzo se inicializa con la dirección
especificada o cero si esta no se indica. En este segmento no puede generarse
ningún código.



El linkador generará una tabla de consulta por cada byte especificado en la sección
idata. El usuario debe entonces linkar o incluir el apropiado código de
inicialización.
Sintaxis:
[<etiqueta>] idata [<dirección RAM>]
Ejemplo:
idata
LimiteV dw 0
LimiteH dw D’300’
Ganancia dw D’5’
Flags db 0
Cadena db ‘¡Hola allí!’

• _ _IDLOCS: Fija cuatro localizaciones ID a los valores de los dígitos en
hexadecimal de <expr>. Por ejemplo, si <expr> es 1AF, la primera localización ID
(dirección más baja) es cero, la segunda uno, la tercera diez, y la cuarta quince.
Antes de usar esta directiva, el tipo de procesador debe ser indicado mediante la
directiva LIST o PROCESSOR. Esta directiva no es válida para la familia de los
PIC17CXX.
Sintaxis:
_ _idlocs <expr>
Ejemplo:
_ _idlocs H’1234’
• IF: Empieza la ejecución de un bloque de ensamblado condicional. Si la
evaluación de <expr> es verdadera, el código que sigue a la directiva IF será
ensamblado. Si no, este código será saltado hasta encontrar una directiva ELSE o
ENDIF.
Una expresión que se evalúa como cero es considerada falsa, siendo verdadera
para cualquier otro valor.
Sintaxis:
if <expr>



Ejemplo:
if version = = 100 ; chequea la versión actual.
movlw 0x0a
movwf io_1
else
movlw 0x01a
movwf io_2
endif

• IFDEF: Si <etiqueta> se ha definido anteriormente, normalmente mediante la
directiva #DEFINE, se toma el camino de la condicional. El ensamblado continua
hasta encontrar la directiva ELSE o ENDIF.
Sintaxis:
ifdef <etiqueta>
Ejemplo:
#define testeo ; testeo activado.
.
.
.
ifdef testeo
<ejecuta el código de test> ; esta parte deberá ser ejecutada.
endif
• IFNDEF: Si <etiqueta> no ha sido previamente definida, o ha sido indefinida por
el uso de la directiva #UNDEFINE, el código que sigue a la directiva será
ensamblado. El ensamblado estará habilitado o deshabilitado hasta la aparición de
la directiva ELSE o ENDIF.
Sintaxis:
ifndef <etiqueta>
Ejemplo:
#define testeo1 ; testeo activado.
.
.
.
#undefine testing1 ; testeo desactivado
ifndef testing1 ; si no está en modo testeo.
. ; ejecuta
. ; esta parte
. ;
endif ;
end ; fin de la fuente.



• INCLUDE: Incluye un fichero adicional a aquel en el que aparezca aquella
directiva.
La sintaxis es:
include <<include_file>>
include “<include_file>”
Si se especifica el directorio donde se encuentra el fichero a incluir, entonces dicho
fichero únicamente se buscará en ese directorio. Si no se especifica ningún
directorio, entonces, el fichero se buscará en primer lugar en el directorio donde
actualmente se esté trabajando, en segundo lugar en el directorio donde se
encuentre el fichero fuente, y en tercer lugar en el directorio donde se encuentra el
fichero ejecutable MPASM.
Ejemplos:
include “c:syssysdefs.inc”
include <regs.h>
• LIST: Permite listar un número determinado de opciones para el programa a
ensamblar, como puede ser por ejemplo especificar el tipo de PIC a usar. Las
distintas opciones que se pueden dar con esta directiva se describen en la tabla 5.3:
TABLA 5.3 Opciones de la directiva LIST.
Opción Por defecto Descripción
b = nnn 8 Fija los espacios de tabulación.
c = nnn 132 Fija el ancho de columna.
Fija el formato de salida del archivo hex, puede
f =<formato> INHX8M
ser INHX32, INHX8M, o INHX8S.
Uso de formato libre(parser). Proporciona
free FIXED
compatibilidad con anteriores.
fixed FIXED Uso de formato fijo.
Imprime el mapa de memoria en el archivo del
mm = ON | OFF On
listado.
n = nnn 60 Fija las líneas por página.
Fija el tipo de procesador; por ejemplo,
p =<tipo> Ninguno
PIC16C54.
r = <radix> hex Fija el radix por defecto: hex, dec, oct.
st = ON | OFF On Imprime una tabla en el archivo del listado.
t = ON | OFF Off Trunca líneas del listado.
w=0|1|2 0 Fija el nivel d errores. Ver ERRORLEVEL.
x = ON | OFF On Pone macro expansión en on u off.
Nota: Todas las opciones de LIST son evaluadas en números decimales.



Sintaxis:
list [<opción_list>, ..., <opción_list>]
Ejemplo:
list p =17c42, f =INHX32, r =DEC

• LOCAL: Declara que los elementos de los datos especificados serán considerados
en el contexto local de la macro. La <etiqueta> puede ser idéntica a otra etiqueta
declarada fuera de la macro, sin haber ningún conflicto entre las dos.
Si la macro es llamada reiteradamente, cada llamada tendrá su propia copia local.
Sintaxis:
local <etiqueta> [, <etiqueta>]
Ejemplo:
<segmento de código principal>
.
.
.
longitud equ 10 ; versión global
tamaño equ 20 ; notar que es una variable local
test macro tamaño
local longitud, etiqueta ; local longitud y etiqueta
longitud set tamaño ; modifica local longitud
etiqueta res longitud
longitud set longitud-20
endm ; fin de la macro

• MACRO: Una macro es una secuencia de instrucciones que puede ser insertada en
el código fuente del ensamblador usando una simple llamada a la macro. La macro
debe de ser definida previamente. Una macro puede a su vez llamar a otra, o a si
misma.
Sintaxis:
<etiqueta> macro [<arg>,..., <arg>]
Ejemplo:
Leer macro dispositivo, buffer, contador
movlw dispositivo
movwf ram_20
movlw buffer ; dirección de buffer.
movwf ram_21
movlw contador ; byte del contador.
call sis_21 ; leer fila call.

• MESSG: Provoca la impresión de un mensaje de información en el archivo del
listado. El texto del mensaje puede ser de hasta 80 caracteres.



Sintaxis:
messg “<texto_de_mensaje>”
Ejemplo:
mssg_macro macro
messg “mssg_macro no tiene argumentos”
endm

• NOEXPAND: Final de la expansión de la macro en el archivo del listado.
• NOLIST: Desactiva las opciones fijadas por la directiva LIST.
• ORG: Establece el origen a partir del cual debe cargarse el programa. Si la
<etiqueta> es especificada, a esta se le dará el valor <expr>. Si no se especifica la
ORG, el código comenzará en la dirección cero.
[<etiqueta>] org <expr>
Ejemplo:
entero_1 org 0x20
. ; El código del vector 20 irá aquí.
entero_2 org entero_1+ 0x10
. ; El código del vector 30 irá aquí.
• PAGE: Inserta un salto de página dentro del archivo del listado.
• PAGESEL: Es una instrucción del linkador para generar código de selección de
página, fijando los bits de selección de página, a la página que contiene la
designada <etiqueta>. Sólo se puede especificar una <etiqueta>, la cual debe estar
previamente definida.
Sintaxis:
pagesel <etiqueta>
Ejemplo:
pagesel IrDestino
...
pagesel CallDestino
call CallDestino.
• PROCESSOR: Indica el tipo de procesador.
La sintaxis es:
processor <tipo_de_procesador>
Ejemplo:
processor 16C54



• RADIX: Fija la base de numeración por defecto de las expresiones de datos. Los
valores válidos para radix son: hex, dec, ó oct.
Sintaxis:
radix <radix_defecto>
Ejemplo:
radix dec
• RES: Produce que el contador de programa avance desde la actual localización
tantas posiciones como se especifican en <unidades_memoria>. La <etiqueta> se
inicializará como una dirección.
Sintaxis:
[<etiqueta>] res <unidades_memoria>
Ejemplo:
buffer res 64 ; reserva 64 palabras de almacenaje.
• SPACE: Inserta <expr> números de líneas en blanco en el archivo de listado.
Sintaxis:
space <expr>
Ejemplo:
space 3 ; Inserta tres líneas en blanco.
• TITLE y SUBTITLE: <texto_de_título> y <texto_subtítulo> son cadenas
imprimibles de caracteres ASCII encerradas por un doble entrecomillado. Éstas
deben ser de 60 caracteres como máximo. Estas directivas imprimen en la cabecera
de cada página del archivo de listado el texto del título y subtítulo, siendo este
último en la segunda línea.
Sintaxis:
title “<texto_de_título>”
subtitle “<texto_subtítulo>”
Ejemplo:
title “Código operacional, rev 5.0”
subtitle “sección de diagnóstico”



• UDATA: Se utiliza en la generación de código objeto. Indica el comienzo de una
sección de datos no inicializados. Si <etiqueta> no se especifica, a la sección se la
nombrará udata. Si no se indica la dirección, ésta se inicializará a cero. En este
segmento no se puede producir código.
Sintaxis:
[<etiqueta>] udata [<dirección RAM>]
Ejemplo:
udata
Var1 res 1
Doble res 2
• UDATA_OVR: Se utiliza en la generación de código objeto. Indica el inicio de
una sección de datos no inicializados reutilizables. Si <etiqueta> no se especifica, a
la sección se la nombrará udata_ovr. Si no se indica la dirección, ésta se
inicializará a cero. El espacio ocupado por esta sección puede ser cubierto por otra
sección udata_ovr del mismo nombre. Esto es una buena forma de crear variables
temporales, permitiendo declarar múltiples variables en la misma localización de
memoria. En este segmento no se puede producir código.
Sintaxis:
[<etiqueta>] udata_ovr [<dirección RAM>]
Ejemplo:
Temps udata_ovr
Temp1 res 1
Temp2 res 1
Temp3 res 1
Temps udata_ovr
LargoTemp1 res 2
LargoTemp2 res 2

• UDATA_SHR: Se utiliza en la generación de código objeto. Indica el inicio de
una sección de datos no inicializados compartidos. Si <etiqueta> no se especifica,
a la sección se la nombrará udata_shr. Si no se indica la dirección, ésta se
inicializará a cero. Esta directiva se usa para declarar variables que están situadas
en RAM que está compartida por todos los bancos. En este segmento no se puede
producir código.
Sintaxis:
[<etiqueta>] udata_shr [<dirección RAM>]



Ejemplo:
Temps udata_shr
Temp1 res 1
Temp2 res 1
Temp3 res 1

• #UNDEFINE: <etiqueta> es un identificador previamente definido por la
directiva #DEFINE. El símbolo nombrado es borrado de la tabla de símbolos.
Sintaxis:
#undefine <etiqueta>
Ejemplo:
#define largo 20
.
.
.
#undefine largo

• WHILE y ENDW: Las líneas que se encuentren entre las directivas WHILE y
ENDW serán ensambladas con tal de que la evaluación de <expr> sea verdadera.
Una expresión evaluada como cero se considera falsa, cualquier otro valor es
verdadero. Un lazo WHILE puede contener hasta 100 líneas y repetirse un máximo
de 256 veces.
Sintaxis:
while <expr>
.
.
.
endw
Ejemplo:
test_macro macro contador
variable I
i=0
while i < contador
movlw i
i+=1
endw
endm
inicio
test_macro 5
end



5.3 Creación de programas

A la hora de crear un programa se pueden dar varias situaciones. Se puede partir o bien de un
sólo código fuente, o de varios de éstos. La forma de actuar en cada caso es distinta ya que
habrá que en un caso bastará con el ensamblador, mientras que en el otro se necesitará además
en linkador o montador de enlaces.

La utilización de librerías precompiladas es una solución de gran utilidad a la hora de crear
programas, ya que facilitan notablemente el trabajo del programador.

5.3.1 Un solo código fuente (ensamblador).

La traducción del código nemónico al código máquina se realiza con la ayuda de un
ordenador sobre el que corre un programa ensamblador.

Los datos de entrada del ordenador son las líneas de programa escritos en lenguaje
ensamblador. Se trata, por tanto, de caracteres alfanuméricos codificados en código ASCII. El
ordenador que está ejecutando el programa ensamblador interpreta estos datos y los traduce al
código máquina del procesador. El ensamblador de los microprocesadores PIC es el MPASM.
Éste produce el código necesario para programar el dispositivo directamente de los archivos
con extensión .HEX.

MPASM puede ser utilizado de dos maneras:
• Generando un código absoluto que puede ser ejecutado directamente por el
microcontrolador.
• Generando código objeto que puede ser linkado junto con otro programa
ensamblador o módulos compilados.

La opción más común del uso de MPASM es la generación de código absoluto. Cuando un
archivo fuente es ensamblado de esta manera, todos los valores usados en este deben estar
definidos dentro del mismo archivo fuente, o en los archivos que son implícitamente



incluidos. Si el proceso de ensamblado se produce sin errores, se generará un archivo .HEX,
que contiene el código máquina ejecutable. Este archivo puede ser, entonces, usado junto con
un programador para programar el microcontrolador. Este proceso se ilustra en la figura 5.1.

Figura 5.1 Generación de código absoluto.

MPASM también tiene la habilidad de generar módulos objeto que pueden ser linkados junto
con otros módulos para generar el código ejecutable, usando el linkador MPLINK. También
pueden agruparse los módulos relacionados y guardarse juntos en una biblioteca utilizando
MPLIB. Las bibliotecas requeridas pueden especificarse en el momento del linkado, y sólo se
incluirán las rutinas necesarias en el archivo ejecutable final.

5.3.2 Varios códigos fuente (linkador).

Por regla general, el código objeto producido por los ensambladores, aunque es código
máquina, no es directamente ejecutable, debido a que incluye una serie de informaciones
dirigidas a otro programa, el montador de enlaces o linkador, que en base a esta información
adicional, organiza el código máquina de uno o varios códigos objeto para generar un
programa ejecutable.

Una de las razones que justifican este modo de trabajo, consiste en la posibilidad de
desarrollar programas voluminosos en varios módulos de tamaño razonable. Por otro lado,
permite la inclusión de módulos, desarrollados para otras aplicaciones y ya depurados, en
nuevos programas, sin necesidad de incluirlos en los fuentes y volver a ensamblarlos.



Otra característica importante del programa montador de enlaces es que, como su información
de entrada son módulos objeto, éstos pueden proceder de programas fuentes escritos en
distintos lenguajes, lo que permite escribir la mayor parte de un programa en lenguaje de alto
nivel, y las rutinas más conflictivas en lenguaje ensamblador. Esto es una solución muy
interesante para simplificar el desarrollo de programas.

El ensamblador de los microcontroladores PIC es el MPLINK. MPLINK combina la entrada
de múltiples códigos objeto generados por MPLAB-C o MPASM, dentro de un solo archivo
ejecutable. Las direcciones de los datos y la localización de las funciones serán asignadas al
ejecutar MPLINK. Una vez que el linkador sabe que regiones de la memoria RAM y ROM
están disponibles y analiza todos los archivos de entrada, intentará encajar las rutinas de
aplicación dentro de la ROM y asignará los datos y variables en la memoria RAM disponible.
Si hay demasiado código o demasiadas variables para encajar, MPLINK dará un mensaje de
error.

MPLINK también permite flexibilidad especificando que ciertos bloques de la memoria de
datos sean reutilizables, así rutinas diferentes (que nunca se llamen simultáneamente y los
datos no sea necesario tenerlos retenidos entre cada ejecución) pueden compartir el espacio
limitado de RAM. En las figuras 5.2 se puede ver el proceso de generación de código a partir
de varias fuentes.

5.3.3 Utilización de librerías.

MPLIB son librerías en código precompilado para usar con MPLINK. Cuando una rutina de
una librería es llamada por otra fuente, sólo los módulos que contienen a la rutina serán
linkados con la aplicación. Esto permite grandes librerías usadas eficazmente en muchas
aplicaciones. En la figura 5.3 se ilustra el proceso de creación de librerías.



Figura 5.2 Generación de código ejecutable a partir de módulos objeto.

Figura 5.3 Creación de librerías de código reusable.



5.4 Estructuras básicas de programación.

5.4.1 Estructuras iterativas.

Este tipo de estructuras se caracteriza porque son bucles que se repiten mientras que una
condición se esté cumpliendo. Existen tres tipos de estructuras, while, do while y for.

5.4.1.1 While.

La estructura while consiste en la repetición de un bucle mientras que se cumpla una
condición.

La forma de programar una estructura de este tipo en los PIC sería testeando un flag que
indique si la condición para la ejecución del bucle se cumple o no. Si esta condición se
cumple se ejecuta el bucle terminando éste con un retorno a la línea de testeo del flag. Si no se
cumple la condición, mediante una instrucción de salto incondicional se salta el bucle
continuando con la ejecución del programa. Durante la ejecución del bucle el flag deberá ser
actualizado ya que si no se formaría un bucle infinito.

El listado de programa de una estructura while quedaría aproximadamente de la siguiente
forma:
...
BUCLE BTFSS FLAG,0 ; Se testea el bit menos significativo de la variable FLAG.
GOTO FIN ; Si este bit es ‘0’ se salta al final del bucle.
... ; Si no se ejecuta el bucle.
...
...
GOTO BUCLE ; Se realiza un salto al principio del bucle para ver si la condición se
; sigue cumpliendo.
FIN ... ; Continua la ejecución del programa.
...



5.4.1.2 Do while.

La estructura do while es similar a la anterior, diferenciándose en que en la estructura while
puede no ejecutarse nunca, mientras que con do while el bucle se ejecuta por lo menos una
vez.

La forma de programar esta estructura es igual que el caso anterior, cambiando la condición
de testeo al final del bucle, asegurando de esta forma que el bucle se ejecuta por lo menos una
vez. Si se cumple la condición se vuelve al principio del bucle y si no se continua con la
ejecución del programa. Al igual que en el caso anterior, el flag deberá ser actualizado durante
el bucle ya que si no se formaría un bucle infinito.

El listado del programa quedaría así:
...
BUCLE ... ; Comienza la ejecución del bucle.
...
...
BTFSC FLAG,0 ; Se testea el bit 0 de la variable FLAG
GOTO BUCLE ; Si se cumple la condición se salta al principio del bucle.
... ; Si no se continua la ejecución del programa.

5.4.1.3 For.

La estructura for consiste en la repetición de un bucle mientras una variable, inicializada al
principio del bloque for y modificada en cada ciclo de ejecución del bucle, cumpla una
determinada condición.

La forma de programar una estructura de este tipo en los PIC sería inicializando una variable
y a continuación escribir todas las instrucciones que componen este bucle. Al final del bucle
se modifica el valor de la variable, y se comprueba si se cumple la condición del bucle. Esto
último se hace mediante los códigos de condición que se verán más adelante. En el caso de
que la condición se cumpla, se repite de nuevo el bucle sin actualizar la variable, si no se
continua con la ejecución del programa.



Un ejemplo de este tipo de estructura sería:
...
CLRF VAR ; Se inicializa la variable a ‘0’.
BUCLE ... ; Comienza la secuencia de instrucciones del bucle.
...
...
INCF VAR,1 ; Se modifica la variable.
... ; Aquí debe ir el código de condición que terminará con la
... ; instrucción de testeo.
BTFSC FLAG,0 ; Instrucción de testeo. FLAG puede ser cualquier variable, según el
; tipo de condición.
GOTO BUCLE ; Si se cumple la condición se salta al principio del bucle.
... ; Si no continua la ejecución del programa.
...

5.4.2 Estructuras condicionales.

5.4.2.1 If .

La estructura condicional if consiste en la ejecución de las secuencias que tenga asociada si se
cumple una condición, en caso contrario esta parte del programa se salta y no es ejecutada.

La forma de programar una estructura de este tipo en los PIC sería testeando un flag que
indique si la condición para la ejecución se cumple o no. Si esta condición se cumple se sigue
ejecutando las instrucciones, mientras que si no se cumple la condición se realiza un salto
incondicional hasta el final de la zona de programa de la estructura if, continuando con la
ejecución del programa.

...
BTFSS FLAG,0 ; Se testea el bit 0
GOTO FIN ; Si no se cumple la condición se salta hasta el fin de la condicional.
... ; Si se cumple se ejecuta todo.
...
...
FIN ... ; Continua la ejecución del programa principal.



5.4.2.2 If ... else.

La estructura if ...else es similar a la anterior, salvo que si no se cumple la condición, en vez
de continuar con el programa, se ejecuta otra parte antes de seguir con el programa.

La forma de programarlo sería muy parecida al caso anterior. Se testea el flag de condición, si
se cumple la condición se ejecutan las secuencias asociadas a la condición, terminando con un
salto incondicional al final de la estructura. Si la condición no se cumple, se salta a la
instrucción siguiente a donde terminó la condicional y se ejecuta la parte del else, continuando
después con la ejecución normal del programa.

...
BTFSS FLAG,0 ; Se testea el bit 0
GOTO ELSE ; Si no se cumple la condición se salta hasta el fin de la condicional.
... ; Si se cumple se ejecuta esta parte.
...
...
GOTO FIN ; Se salta hasta el final del bloque if ...else.
ELSE ... ; Si no se cumple la condición se ejecuta esta parte.
...
...
FIN ... ; Continua la ejecución del programa principal.

La encadenación de bloques if ... else da lugar a la estructura conocida en el lenguaje C como
switch. En esta estructura según los distintos valores que pueda tener la variable se ejecutará
una serie de sentencias.

Un ejemplo de la programación de esta estructura es el siguiente:
...
MOVLW CASO1 ; mueve el valor de la variable en el 1º caso al acumulador.
SUBWF VAR,0 ; Resta el valor de la variable y el valor en el caso1.
BTFSS STATUS,Z ; Comprueba si son iguales.
GOTO SIGUE_2 ; Si no lo es salta hasta la posición del siguiente caso.
.... ; Si son iguales se ejecuta esta secuencia de instrucciones.
....
GOTO FIN ; Al final de la secuencia se sale de la estructura.
SIGUE_ 2 MOVLW CASO2 ; Se repite hasta que se den todos los casos posibles.
...
...
SIGUE_N ... ; Si se llega al último caso se ejecutan las instrucciones que



... ; haya sin necesidad de ninguna comparación.
FIN ... ; Continua el programa principal.
...

5.4.3 Códigos de condición.

En este apartado se va a tratar la forma de realizar el código para saber si una condición se
cumple o no. Este código dependerá del tipo de condición que se quiera verificar.

5.4.3.1 Igual.

Para verificar mediante la programación que dos valores son iguales, se procede restándolos
entre si, y testeando el bit de cero del registro de Estado. Si son iguales, éste se pondrá a ‘1’.

Por ejemplo:
MOVF VALOR_1,0 ; Mueve el VALOR_1 al registro de trabajo.
SUBWF VALOR_2,0 ; Resta los valores entre si.
BTFSS STATUS,Z ; Testea bit de cero.
GOTO DISTINTO ; Salta a la zona de programa correspondiente si no se
; cumple la condición de igualdad.
... ; Se ejecuta esta instrucción correspondiente a la igualdad
; de los dos valores.

5.4.3.2 Distinto.

La forma de programar una condición de no igualdad es la misma que la de igualdad. Esto se
puede ver en el ejemplo del apartado anterior, cuando no se cumple la igualdad, se salta a la
posición DISTINTO, donde se ejecutará las secuencias correspondientes.

5.4.3.3 Mayor.

Para realizar el código de la condición mayor lo que se hace es restar los dos números a
comparar y testear el bit de carry del registro de Estado. Al hacer esto hay que tener en cuenta
que la resta en los PIC se realiza mediante el complemento a dos. Teniendo dos números A y
B, se resta el primero del segundo y si el bit C = 0, se cumplirá que A>B.



5.4.3.4 Mayor o igual.

Si lo que se quiere es que A sea mayor o igual que B, entonces la operación a realizar sería la
contraria, es decir A – B, si el carry es ‘1’, la condición se cumple.

5.4.3.5 Menor.

Para comprobar que el valor A es menor que B, al igual que en el caso anterior, se resta B de
A, cumpliéndose la condición A<B si el carry es ‘0’.

5.4.3.6 Menor o igual.

El caso que queda es el de querer que A sea menor o igual que B. Para esto se resta A de B y
se comprueba que el carry está a ‘1’.

5.4.3.7 Condiciones más complejas.

Por último, puede haber códigos de condición más complejos que los anteriormente
mencionados, que consisten en operaciones lógicas y/o aritméticas.

Para este tipo de condicionales no existe una estructura fija. Como norma general para realizar
su programación se ha de proceder de forma que se realicen primero las operaciones incluidas
dentro de los paréntesis, y las operaciones lógicas y aritméticas. Por último se realizan las
operaciones de comparación.

A continuación se muestra un ejemplo de programación de una condicional compleja de la
forma (A || B) = = ( A && (B ⊕ C)):
...
...
MOVF A,0 ; Mueve A al acumulador.
IORWF B,0 ; Realiza la o lógica entre A y B.
MOVWF DRCH ; Guarda el resultado de la parte derecha de la igualdad en DRCH.
MOVF B,0 ; Mueve B al acumulador.
XORWF C,0 ; Realiza la o exclusiva entre B y C.



MOVWF PARENT ; Guarda el resultado del paréntesis en PARENT.
COMF A,0 ; Complementa A.
ANDWF PAREN,0 ; Realiza la y lógica entre el complemento e A y PARENT
SUBWF DRCH,0 ; Resta PARENT de DRCHA.
BTFSS STATUS,Z ; Testea en bit de cero.
BCF FLAG,0 ; Si Z =0 no se cumple la condición y borra el FLAG.
GOTO SIGUE
BSF FLAG,0 ; Si Z =1 activa el FLAG.
SIGUE ...
...

5.5 Ejemplo de librerías: librerías matemáticas.

5.5.1 Rutinas de coma flotante.

Dentro de esta libraría se pueden encontrar las siguientes rutinas matemáticas para la familia
de los microcontroladores PIC:
• Conversión de flotante a entero.
• Conversión de entero a flotante.
• Normalización.
• Suma/resta.
• Multiplicación.
• División.

Los formatos de coma flotante que se van a utilizar se resumen en la tabla 5.4:

TABLA 5.4 Formatos de coma flotante.
eb f0 f1 f2
IEEE754 32-bits sxxx xxxx y’xxx xxxx xxxx xxxx xxxx xxxx
Microchip 32-bits xxxx xxxx s’xxx xxxx xxxx xxxx xxxx xxxx
Microchip 24-bits xxxx xxxx s’xxx xxxx xxxx xxxx

Siendo eb los 8 bits del exponente, s el bit de signo, y el bit menos significativo del registro
eb, y ’ la coma . Los bytes f0, f1 y f2 constituyen la fracción del número siendo f0 el byte más
significativo.



Los registros asociados a las operaciones en coma flotante son los siguientes:
AARGB7 = ACCB7 = REMB3 Del LSB al MSB.
AARGB6 = ACCB6 = REMB2
AARGB5 = ACCB5 = REMB1
AARGB4 = ACCB4 = REMB0 Resto.
AARGB3 = ACCB3
AARGB2 = ACCB2
AARGB1 = ACCB1
AARGB0 = ACCB0 = ACC Fracción de AARG y ACC.
AEXP = EXP Exponente de AARG y ACC.

SIGN Signo en MSb.
FPFLAGS Flags de excepciones y bits de opciones.

BARGB3 Del LSB al MSB
BARGB2
BARGB1
BARGB0 Fracción de BARG
BEXP Exponente de BARG.

TEMPB3
TEMPB2
TEMPB1
TEMPB0 = TEMP Almacenamiento temporal.
Los flags de excepción y los bits de opciones de FPFLAGS están definidos de la siguiente
manera:
FPFLAGS SAT RND DOM NAN FDZ FUN FOV IOV
7 6 5 4 3 2 1 0
SAT Bit de habilitación de Saturación.
RND Bit de habilitación de redondeo.
DOM Flag de error de dominio.
NAN Flag de excepción “No es un Número”
FDZ División por cero.
FUN Flag de underflow en coma flotante.
FOV Flag de overflow en coma flotante.
IOV Flag de overflow en enteros.

Para operaciones unarias (un sólo operando), la entrada del argumento y el resultado están en
AARG. Para operaciones binarias la entrada de datos se realiza en AARG y BARG,
cargándose el resultado en AARG. De este modo se simplifican la secuencia de las
operaciones.



5.5.1.1 Manejo de excepciones.

Todas las rutinas devuelven en WREG = 0x00, en una operación correcta, y WREG = 0xFF
en caso de que se produzcan excepciones junto con los bits implicados de FPFLAGS a ‘1’. Si
SAT = 0, la saturación está deshabilitada y en una excepción se obtiene un resultado falso en
AARG. Si SAT = 1, saturación habilitada, en todas las excepciones de overflow o underflow
producen la saturación del resultado en AARG.

5.5.1.2 Redondeo.

Con RND = 0, el redondeo está deshabilitado, obteniendo algunas mejoras en la velocidad. Si
RND = 1, el redondeo está habilitado, produciéndose este en el LSb más cercano al resultado.

5.5.1.3 Conversión de entero a flotante.

La rutina FLOxxyy convierte los xx-bits de un entero en complemento a dos contenidos en
AARG, en un número de yy-bits a coma flotante, guardando el resultado en AEXP, AARG.
La rutina inicializa el exponente al mover la coma a la derecha del bit más significativo y
llama a la rutina de normalización. Por ejemplo:
FLO1624 (12106) = FLO1624 (0x2F4A) = 0x8C3D28 = 12106.0 (5.1)

5.5.1.4 Normalización.

La rutina NRMxxyy toma un número en coma flotante de xx-bits no normalizado de AEXP,
AARG y rota hacia la izquierda la fracción ajustando el exponente hasta que el resultado tiene
un ‘1’ en el bit más significativo, convirtiéndolo de este modo en un número de yy-bits en
coma flotante normalizado.



5.5.1.5 Conversión de flotante a entero.

La rutina INTxxyy convierte un número en coma flotante de xx-bits AEXP, AARG, en un
número entero en complemento a dos de yy-bits en AARG. Después de quitar el sesgo de
AEXP, la fracción en AARG es desplazada a la izquierda tantas posiciones como indique
AEXP, pasándolo después a complemento a dos. Por ejemplo:
INT2416 (123.45) = INT2416 (0x8576E6) = 0x7B = 123 (5.2)

5.5.1.6 Suma/Resta.

La rutina de suma en coma flotante FPAxx, toma los datos de AEXP, AARG y BEXP,
BARG, devolviendo el resultado de la operación en AEXP, AARG. Si es necesario los datos
son intercambiados entre si, de modo que se cumpla que AEXP≥BEXP. Una vez que se ha
hecho esto, BARG se desplaza a la derecha tantas posiciones como diferencia hay entre los
dos exponentes (AEXP – BEXP). Los argumentos son entonces sumados y el resultado es
normalizado llamando a NRMxx.

La rutina de resta FPSxx, simplemente cambia el bit de signo de BARG y llama a la rutina
FPAxx.

Algunos ejemplos son:
FPA24(-0.32212E+5, 0.1120E+4)= FPA24(0x8DFBA8, 0x890C00) = 0x8DF2E8 = -0.31092+E5 (5.3)

FPS24(0.89010E+4, -0.71208E+5) = FPS24(0x8C0B14, 0x8F8B14) = 0x8F1C76 = 0.80109E+5 (5.4)

5.5.1.7 Multiplicación.

La rutina de multiplicación en coma flotante FPMxx, al igual que las rutinas de suma toma los
datos de AEXP, AARG y BEXP, BARG y devuelve el producto en AEXP, AARG. Después
de testear los operandos para ver si alguno es cero, calcula el resultado del signo y el
exponente y ve si se ha producido overflow.



En los PIC17, los argumentos se multiplican usando el multiplicador hardware, mientras que
en los PIC16 se hace mediante el método de la suma y desplazamiento. En ambos casos va
seguido de una normalización del resultado si es necesario.

Por ejemplo:
FPM32 (-8.246268E+6, 6.327233E+6) = FPM32 (0x95FBA7F8, 0x95411782) = (5.5)
= 0xACBDD0BD = -5.217606E+13

5.5.1.8 División.

La rutina de división en coma flotante FPDxx, toma AEXP, AARG como numerador y a
BEXP, BARG como denominador, devolviendo el cociente en AEXP, AARG.

En los PIC17 se implementa utilizando el multiplicador hardware con un método iterativo
conocido como división multiplicativa. Una vez comprobado que no se trata de una división
por cero, se toma un valor inicial de una tabla de consulta para comenzar el proceso iterativo.
Para la familia PIC16, después de testear el denominador para ver si es cero, el signo y el
exponente del resultado se calculan junto con la alineación del dividendo. Si AARG ≥ BARG,
el dividendo AARG es desplazado una posición a la derecha ajustando también el exponente,
de modo que AARG < BARG y el dividendo esté alineado. La alineación permite una
secuencia válida de división y elimina la necesidad de una posterior normalización del
resultado. Después de testear si hay overflow o underflow, las fracciones son divididas usando
el método del desplazamiento y resta.

Un ejemplo sería:
FPD24 (-0.16106E+5, 0.24715E+5) = FPD24 (0x8CFBA8, 0x8D4116) =
= 0x7EA6D3 = -0.65167E+0 (5.6)



5.5.2 Rutinas en coma fija.

Las rutinas que tiene implementadas esta aplicación para coma fija son:
• Multiplicación.
• División.
Estas rutinas permiten gran variedad de formatos de coma fija, incluyendo aritmética sin
signo y con signo en complemento a dos.

Las aplicaciones de suma y resta no se incluyen en esta librería ya que este tipo de
operaciones se puede realizar directamente con las instrucciones del programa.

5.5.2.1 Multiplicación.

Esta rutina permite la multiplicación de datos con los siguientes tipos de formato:
• 8x8
• 16x8
• 16x16
• 24x16
• 24x24
• 32x16
• 32x24
• 32x32

La rutina de multiplicación en coma fija FXMxxyy, toma un multiplicando de xx-bits de
AARG, un multiplicador de yy-bits de BARG y devuelve un resultado de (xx+yy)-bits en
AARG.

Para la familia PIC17, ambos algoritmos, tanto con signo como sin signo, usan la aplicación
hardware multiplicación de 8x8 con precisión extendida. Al hablar de precisión extendida ,
cada argumento se ve como una concatenación de bytes de distinto orden de magnitud, siendo
el producto la evaluación de todos los términos 8x8 de la expresión algebraica. Por ejemplo,



una multiplicación de 24x16 bits da un producto de 40 bits y en su expansión contiene 6
términos individuales de 8x8.
(AARGB0·216 + AARGB1·28 + AARGB2·20) · (BARG0·28 + BARG1·20) = (5.7)
AARGB0·BARGB0·224 + (AARGB0·BARGB1 + AARG1·BARG0)·216 +
(AARGB1·BARGB1 + AARGB2·BARGB0)·28 + AARGB2·BARGB1·20
Esto es completamente análogo a la aritmética en base 28 = 256, donde los respectivos dígitos
del producto deben ser alineados de acuerdo con su orden de magnitud antes de ser sumados.

La rutina multiplicación en coma fija requiere el uso adecuado de los factores 8x8 del
multiplicador hardware, ya que éste es para operandos sin signo. Esta probado que el producto
de los números con signo en complemento a dos se obtiene calculando su producto como si se
tratara de un número sin signo , y restándole posteriormente por cada término negativo, el
producto de la potencia del bit más significativo por el término opuesto al negativo.

La implementación en la familia PIC16CXXX usa el algoritmo de suma y desplazamiento
secuencial, negando ambos factores si BARG<0, ya que el método requiere que el
multiplicador sea positivo. Los bits del multiplicador se van testeando, si es uno se suma el
multiplicando y se desplaza , si es cero simplemente se desplaza. Los desplazamientos son
necesarios para alinear los productos parciales para la siguiente posible suma.

Dos ejemplos de multiplicación son:
FXM2416S(0xC11682, 0x608B) = FXM2416S(-4123006, 24715) = 0xE84647f896 = -101900093290 (5.8)

FXM1616U (0x0458, 0x822C) = FXM1616U (1112, 33324) = 0x02356F20 = 37056288 (5.9)

5.5.2.2 División.

La rutina de división en coma fija FXDxxyy, toma un dividendo de xx-bits en AARG, y un
divisor de yy-bits en BARG retornando el cociente de xx-bits en AARG y yy-bits de resto en
REM. A diferencia de la multiplicación, la división no es determinativa, requiere un proceso
de prueba y error con desplazamientos y restas secuenciales. La división binaria es más
sencilla que la decimal, ya que sólo son posibles dos valores como cociente, cero o uno. Si el



divisor es menor que el resto parcial, el bit correspondiente del cociente es uno, seguido por
una resta y una desplazamiento. Por el contrario, si es divisor es mayor que el resto parcial, el
bit del cociente es cero y sólo se realiza el desplazamiento.

Los restos parciales intermedios pueden ser restaurados en cada pasos como en una división
con restauración, o corregirlos al final como en una división sin restauración. La
implementación depende de como afecta el peor caso al valor medio de las dos
aproximaciones, por lo que se proporcionan macros para cada método.

El resultado de la división AARG/BARG, satisface la relación:
AARG = BARG · COCIENTE + RESTO, (5.10)
donde el resto es del mismo signo que el cociente. Algunos ejemplos son:
FXD1608S(0xC116, 0x60) = 0xFF59, 0xB6 (5.11)

FXD1616U(0x9543, 0x4AA1) = 0x0002, 0x0001 (5.12)

5.5.3 Funciones matemáticas en coma flotante.

Esta aplicación tiene implementadas las siguientes rutinas matemáticas para la familia de
microcontroladores PIC:
sqrt(x) función raíz cuadrada, x.
exp(x) función exponencial, ex.
exp10(x) función exponencial en base 10, 10x.
log(x) función logaritmo neperiano, ln x.
log10(x) función logaritmo decimal, log10x.
sin(x) función trigonométrica seno.
cos(x) función trigonométrica coseno.
sin cos(x) función trigonométrica seno y coseno.
pow(x, y) función potencia, xy.
floor(x) función entero.
taxxb(a,b) comparación lógica en coma flotante.
rand(x) generador aleatorio de números enteros.



Las rutinas para las familias PIC16CXXX y PIC17CXXX están en un formato modificado de
IEEE 754 de 32 bits junto con versiones en un formato reducido de 24 bits.

Para operaciones unarias, el dato de entrada y el resultado están en AARG, excepto las rutinas
sin cos, en las cuales el coseno se almacena en AARG y el seno en BARG. La función
potencia requiere entrada de datos en AARG y BARG, obteniendo el resultado en AARG.
Aunque las rutinas de comparación lógica también requieren entrada de datos en AARG y
BARG, el resultado se obtiene en el registro W.

5.5.3.1 Función raíz cuadrada.

El dominio natural de la función raíz cuadrada es todos los números positivos, siendo el
dominio efectivo [0, MAXNUM], entendiendo por MAXNUM el mayor número que se puede
representar en formato de coma flotante. Todas las rutinas empiezan por un testeo del dato
para ver si está dentro del dominio, produciendo un error de dominio en caso de que esté fuera
del intervalo.

En los PIC17CXXX utilizan el multiplicador hardware para resolver la raíz cuadrada
mediante el método iterativo por aproximaciones sucesivas de Newton – Raphson. Siendo
x = f · 2 e , donde 1 ≤ f < 2, al calcular su raíz se utilizan las siguientes expresiones:
e
2
x = f ·2 ,si e es par (5.13)

e
2
x = f· 2 ·2 , si e es impar (5.14)

La aproximación para f se calcula mediante el método de Newton – Raphson, partiendo de
un valor tabulado.
⎛ f ⎞
y = ⎜ y0 +
⎜ ⎟/2 (5.15)
⎝ y0 ⎟
⎠

Debido a que la memoria de los PIC16CXXX es más pequeña, se han de buscar métodos
alternativos para resolver esta función. En este caso, para el formato de 24 bits, la



aproximación f se obtiene por la segmentación en polinomios de cuarto grado, mediante el
método de la aproximación mínima2 (minimax approximation) en los intervalos [1, 1.5] y
[1.5, 2]. En el formato de 32 bits, la función f = 1 + z en el intervalo [0, 1] de z, se obtiene
la aproximación de la forma
p(z)
1 + z = 1+ z , donde z ≡ f + 1. (5.16)
q(z)

5.5.3.2 Funciones exponenciales.

Mientras que el dominio de las funciones exponenciales abarca todos los números reales, la
representación de los números en coma flotante limita el dominio al intervalo [MINLOG,
MAXLOG], siendo:
MINLOG = ln(2-126) (5.17)
MAXLOG = ln(2128) (5.18)

Todas las rutinas empiezan por un testeo del dato para ver si está dentro del dominio,
produciendo un error de dominio en caso de que esté fuera del intervalo.

Para el formato reducido de 24 bits, la función exponencial es evaluada utilizando la siguiente
identidad:
x
ex = 2 ln 2
= 2 n + z = 2 n ·2 z , (5.19)
donde n es un número entero y 0 ≤ z < 1. La función exponencial de base dos, se aproxima
mediante el polinomio mínimo de tercer grado en una representación segmentada en los
subintervalos [0, 0.25], [0.25, 0.5], [0.5, 0.75] y [0.75, 1], con una exactitud de 0.5uld
(unidades de la última posición) a lo largo de todo el dominio [MINLOG, MAXLOG].

2
La teoría conocida como aproximación mínima, consiste en la aproximación de una función mediante un
polinomio de grado n, que cumple que el error máximo es el mínimo posible y debe darse al menos en n+2
puntos, alternando el signo del intervalo de aproximación.



Para el formato de 32 bits, la falta de rutinas de precisión extendida, hace que se requieran
algoritmos más complejos para aproximarse a los 0.5 ulp, y llegando en el peor de los casos a
obtener un error de 1 ulp.
La función exponencial en este caso está basada en una expansión
e x = e z + n ln2 = 2 n · e z , (5.20)
donde n es un entero y –0.5 ln2 ≤ z < 0.5 ln2, evaluando la función exponencial mediante la
aproximación del polinomio mínimo de quinto grado en los subintervalos [-0.5 ln2, 0] y [0,
0.5 ln2].

El argumento z es obtenido de la expresión z = x – n · ln 2. El mayor error producido por este
método viene dado por la realización de esta diferencia., por eso se han desarrollado métodos
de precisión pseudo extendida, donde ln 2 se descompone en dos números, siendo:
ln 2 = c1 – c2 , (5.21)
donde c1 = 0.693359375 y c2 = 0.00021219444005469, haciendo entonces la evaluación de z
de la forma
z = (x – n · c1) + n · c2, (5.22)
donde el término encerrado en el paréntesis se calcula exacto, produciéndose sólo errores de
redondeo en el segundo término.

Las rutinas de la exponencial de base 10 para los formatos de 24 y 32 bits, son completamente
análogas a las rutinas exponenciales vistas anteriormente, sustituyendo la base e por 10 en
cada caso. Estas rutinas son comunes para las familias de los PIC16CXXX y PIC17CXXX.

5.5.3.3 Funciones logarítmicas.

El dominio efectivo de los logaritmos es (0, MAXNUM], donde MAXNUM es el mayor
número que se pueda representar en coma flotante. Todas las rutinas empiezan con un testeo
del argumento para ver si se encuentra dentro del dominio, en caso contrario devuelven un
error de dominio.



Para el formato reducido de 24 bits, dado la disponibilidad de las rutinas de precisión
extendida, la función log se evalúa usando la siguiente identidad:
ln x = ln 2 · log 2 x = ln 2 · (n + log 2 f ) , (5.23)
donde n es un número entero y 0.5 ≤ f <1. El valor de log 2 f = log 2 (1 + z) se obtiene de la
1
representación de la función en los subintervalos de z [ − 1 , 0] y [0, 2 − 1 ], usando la
2
aproximación racional del mínimo de la forma
p(z)
log 2 (1 + z) ≈ z , (5.24)
q(z)
donde p(z) es una función lineal y q(z) cuadrática.

Para un formato de 32 bits, la forma de hacer el logaritmo es mediante la expansión
ln x = ln f + ln 2 n = ln f + n · ln 2, (5.25)
donde n es un número entero y 0.5 ≤ f <1. El valor de ln f = ln(1 + z) se obtiene de la
1
representación de la función en los subintervalos de z [ − 1 , 0] y [0, 2 − 1 ], usando la
2
aproximación racional del mínimo de la forma
⎛ p(z) ⎞
ln(1 + z) ≈ z − 0.5 · z 2 + z ⎜ z 2 ·
⎜ ⎟ , (5.26)
⎝ q(z) ⎟
⎠
donde p(z) es una función lineal y q(z) cuadrática. Esta parte racional da un resultado exacto,
estando el error en el segundo término. Para reducir este error se utiliza para la evaluación, un
método de precisión pseudo extendida que tiene la siguiente aritmética:
ln f + n · ln 2 = (ln f – n · c2) + n · c1 , (5.27)
donde la descomposición de ln 2 es la misma que la utilizada en la función exponencial.

La rutina para el cálculo del logaritmo decimal con el formato de 24 bits es completamente
análogo al del cálculo del logaritmo neperiano cambiando la base e por 10 en todos los casos.



Para el caso del formato de 32 bits, el logaritmo decimal se obtiene mediante la conversión
del logaritmo neperiano, es decir, haciendo la multiplicación en coma fija del logaritmo
decimal de e por el resultado del logaritmo neperiano.
log x = log e · ln x (5.28)

5.5.3.4 Funciones Trigonométricas.

En la evaluación de las funciones seno y coseno, el dominio es infinito, por lo que se
requieren técnicas de reducción de los argumentos.

Susceptibles de errores de redondeo y cancelación, estos procesos siempre fallarán para
argumentos mayores de cierto valor, llevando a la perdida de precisión. El tamaño de este
valor (LOOSTHR), a partir del cual se producen errores, depende del algoritmo utilizado para
la reducción y la precisión deseada, dando un valor de;
π 24 2
LOOSTHR = · 2 = 1024 · π (5.29)
4
para esta implementación usando un método con pseudo precisión extendida y corrientemente
disponible en coma fija y en precisión simple para rutinas en coma flotante. Cuando se sobre
pasa este valor se informa mediante un error de dominio.

Teniendo el argumento x en el intervalo [-LOSSTHR, LOSSTHR], se calcula el argumento z
⎡ π π⎤
comprendido en el intervalo ⎢− , ⎥ , mediante la siguiente definición:
⎣ 4 4⎦
π
z = x mod , (5.30)
4
produciendo la primera evaluación de las relaciones ‘y’ y ‘j’.

x y
y= , j=8· ,
π4 8

donde j indica el octante donde se encuentra el ángulo. Para el uso apropiado de las rutinas de
seno o coseno se introduce una lógica adicional sobre j para obtener el correcto valor del



signo y el reflejo de los ángulos mayores de π. El cálculo de z sigue un método de pseudo
precisión extendida,
π π
z = x mod = x – y · = ((x – p1 · y) – p2 · y) – p3 · y , (5.31)
4 4
donde
π π π
= p1 + p2 + p3 , p1 ≈ y p2 ≈ – p1 , (5.32)
4 4 4
con
p1 = 0.78515625 (5.33)
p2 = 2.4187564849853515624 x 10-4 (5.34)
p3 = 3.77489497744597636 x 10-8 (5.35)

Aunque algunas multiplicaciones se hacen en coma fija, las sumas se hacen todas en coma
flotante. Aunque solo están implementadas las funciones seno y coseno, mediante simples
modificaciones se pueden evaluar el resto de las funciones trigonométricas.

⎡ π π⎤
El polinomio mínimo para las funciones seno y coseno en el intervalo ⎢− , ⎥ se construye
⎣ 4 4⎦
de la siguiente forma:
sen x ≈ x + x · x2 · p(x2) (5.36)
2 4 2
cos x ≈ 1 – 0.5 ·x + x · q(x ) (5.37)
para el formato de 32 bits, donde p y q son polinomios de segundo grado. En el formato de 24
bits se utilizan las expresiones
sen x ≈ x · p(x2) (5.38)
cos x ≈ 1 – x2 · q(x2) (5.39)
donde p y q son de segundo grado.

5.5.3.5 Función potencia.

La función potencia xy, está definida para todo ‘y’ con x>0, sin embargo, para x negativas
sólo está definida cuando ‘y’ es un número entero o una raíz impar. Desafortunadamente, las



fracciones impares tal como 1/3 para la raíz cúbica, no pueden ser representadas exactamente
con un número binario en coma flotante, por eso se plantean problemas en la definición y el
reconocimiento de tales casos. Por tanto, ya que un dato de tipo entero no es soportado en esta
función, el dominio de la función potencia queda restringido al intervalo [0, MAXNUM] para
‘x’ y [-MAXNUM, MAXNUM] para ‘y’, que sujeto a los requerimientos el rango es también
[0, MAXNUM].

Además los siguientes casos especiales serán resueltos de la forma:
x 0 ≡ 1, x≥0
0 y ≡ MAXNUM, y < 0,
donde MAXNUM se puede devolver a través de overflow y saturación si estuviese habilitada.
Cuando las rutinas de precisión extendida están habilitadas, el cálculo de la función potencia
xy es normalmente realizada usando la identidad
xy = exp(y · ln x), (5.40)
contando con la precisión extendida de la evaluación de la función log y de la exponencial
para el control del error de propagación. La implementación para el formato reducido de 24
bits utiliza las funciones log y exponencial de 32 bits obteniendo un error relativo de 0.5 ulp.

La carencia de rutinas de precisión extendida para el formato de 32 bits requiere mayor
esfuerzo y más sofisticados métodos de precisión pseudo extendida para controlar el error de
propagación. Ya que el error relativo ene una función exponencial es proporcional al error
absoluto del argumento, hay que tener especial cuidado con los algoritmos basados en una
identidad exponencial. Estos métodos generalmente tratan de obtener como resultado una
potencia entera de dos, seguida por los cálculos requeridos por las aproximaciones, sobre un
intervalo relativamente pequeño. Para esto, la representación del argumento x viene dada por:
x = f · 2 e , donde 0.5 ≤ f < 1. (5.41)

La función potencia se puede expresar de la forma:
x y = 2 y · log 2 x , (5.42)



con el logaritmo en base 2 de x representado como
⎛ f −a⎞
( ) ⎛ a ·f
log 2 x = log 2 f · 2e = e + log 2 ⎜
⎞
⎟ = e + log 2a + log 2 ⎜1 + ⎟, (5.43)
⎝ a ⎠ ⎝ a ⎠
donde a es elegida para que (f – a)/a sea pequeño.

En lugar de un simple valor de a, se eligen una serie de valores de la forma
a k = 2− k 16 , k = 0, 1..., 16, (5.44)
resultando una efectiva representación segmentada. Para un dado f, se tomará el valor ak más
cercano a f, resultando un argumento v = (f – ak) / ak para la función
log 2 (1 + v), 2 −1 16 − 1 < v < 21 16 − 1 . (5.45)

Ya que el número ak no se puede representar exactamente con entera precisión, se realiza la
evaluación de v mediante la pseudo precisión extendida de la forma
(f − a k ) ⎛ f − A k − Bk ⎞
=⎜
⎜ A +B ⎟,
⎟ (5.46)
ak ⎝ k k ⎠
donde a k = A k + B k . Este método asegura la evaluación de v con un error relativo máximo
menor de 1 ulp. La aproximación del polinomio mínimo es de la forma
v2
log(1 + v ) ≈ v −
p(v)
+ v3 · , (5.47)
2 q(v)
siendo q y p polinomios de primer grado. A partir de este resultado se realiza la conversión a
logaritmo en base dos, obteniendo al final que
k
log 2 x = e− + log 2 (1 + v) . (5.48)
16

Ahora el producto y · log 2 x es cuidadosamente calculado reduciendo el número ‘y’ a una
suma de dos partes con una de ellas menor a 1/16, evaluando pequeños productos de similar
magnitud y agrupando los términos. Cada fase de esta estrategia está seguida por una
operación similar de reducción de operandos donde la mayor parte corresponde a un entero
más un número de dieciseisavo.



La forma final del producto es un número entero más un número de dieciseisavo más un
número del intervalo [-0.0625,0], siendo el resultado final:
x y = 2 y · log 2 x = 2 i · 2 -n/16 · 2 h , (5.49)
donde 2h es evaluada por la aproximación mínima de la forma
2 h − 1 ≈ h + h · p(h) , (5.50)
siendo p un polinomio de segundo grado.

Normalmente esta función sólo es soportada por los PIC17CXXX.

5.5.3.6 Función parte entera por defecto.

Otra función de las librerías matemáticas es la operación floor(x) ≡ ⌊x⌋, la cual encuentra el
mayor entero no superior a x, y lo expresa en coma flotante. La implementación usada aquí
encuentra la localización del punto binario implícito en el exponente, determinando de este
modo el bit por debajo del cual hay que poner todo a cero.
Dos ejemplos de esta función son:
FLOOR24 (123.45) = FLOOR24 (0x8576E6) =0x857600 = 123.0 (5.51)
FLOOR24 (-123.45) = FLOOR24 (0x85F6E6) =0x857800 = -124.0 (5.52)

5.5.3.7 Comparación lógica en coma flotante.

En los cálculos frecuentemente se requiere relacionar números mediante los operadores <
(menor), <= (menor o igual), > (mayor), >= (mayor o igual), ═ ═ (igual), != (distinto). Estas
comparaciones se realizan llamando a las rutinas TALTBxx (A<B), TALEBxx (A<=B),
TAGTBxx (A>B), TAGEBxx (A>=B), TAEQBxx (A=B), y TANEBxx (A!=B).

Las comparaciones necesarias se hacen empezando por el exponente, seguidas si es necesario
por los bytes que forman la mantisa empezando por los de mayor peso, hasta completar todos
los bits. Los argumentos son testeados en los registros AARG y BARG, devolviendo como
resultado un entero en W, que será un uno en caso de que la condición se dé y un cero si no es
cierta.



5.5.3.8 Generador aleatorio de números enteros.

La utilización de la función rand() de las librerías de estándar de C genera un número
aleatorio entero no negativo que se utiliza como semilla para la función srand(x), donde x es
un entero. Esta implementación del generador de números aleatorios utiliza un método basado
en la siguiente relación:
x i +1 = (a · x i + c) mod m, (5.53)
con un multiplicador a, un incremento c, módulo m y un número inicial x 0 . Estas constantes
se seleccionan cuidadosamente para asegurar el máximo periodo, junto con otros importantes
criterios para su realización. Aquí x es elegido como un entero de 32 bits. Las constantes
usadas en la implementación de esta rutina son:
a = 1664525, (5.54)
c = 1, (5.55)
m = 2 32 (5.56)

En este caso el valor del módulo coincide con el periodo del generador, indicando que son
posibles todos los enteros de 32 bits.
RAND_MAX = 2 32 -1 =4294967295. (5.57)

5.5.4 Conversión de coma flotante a ASCII.

A menudo es necesario a la salida un número en coma flotante en un display. Por ejemplo,
para verificar cálculos, uno quiere a la salida números en coma flotante usando el puerto serie
de los microcontroladores PIC, o usar una E/S de propósito general junto con un display de
cristal líquido (LCD).

De cualquier modo, el número en coma flotante debe convertirse a su equivalente en ASCII.
Aquí se muestra un ejemplo específico de conversión de un número en coma flotante de 32
bits a ASCII. Una subrutina que se proporciona aquí hace la conversión y devuelve en
equivalente ASCII en la RAM.



5.5.4.1 Conversión de coma flotante a ASCII en base 10.

El rango de los números en coma flotante es: ±1.17549435x10-38 a ±6.80564693x10+38. Esta
aplicación sólo muestra la conversión de los números desde el 0.000 hasta 9.999. con
modificaciones, este método puede ser extendido para convertir otro rango de números
también.

Se debe asegurar que los registros AARG estén cargados con el correcto número en formato
coma flotante de 32 bits: tanto como resultado de una operación anterior o cargándolo
manualmente en AARG.

Para la demostración se tomará una aproximación de π y se cargará en el registro AARG. El
número usado será 3.1415927. Entonces se llama a la subrutina float_ascii. Antes de regresar
de la rutina, los números de la representación del número en coma flotante es guardado en
base 10 de ASCII en registros RAM: unidades, décimas, centésimas, y milésimas. Cada uno
de estos registros representa a un carácter en código ASCII. El punto decimal no se incluye en
los registros RAM. Ya que el número a representar esta entre 0.000 y 9.999, la rutina de
actualización del display debe poner un punto decimal después de la salida del primer dígito.
El resultado es el número “3.141”.

5.5.4.2 Personalización de la rutina.

Hay varios cambios que se pueden realizar a la rutina float_ascii para personalizarla.
El número de cifras significantes se especifica mediante la constante SIG_FIG. Suponiendo
que se quiere un dígito más de exactitud, es decir, cuatro dígitos a la derecha del punto
decimal, es muy fácil cambiar el archivo floasc.inc para lograr estas características.

Los pasos a seguir al cambiar el código fuente para obtener a la salida un total de cinco
dígitos son:
1. Asegurarse de que hay suficientes registros RAM, uno por cada dígito. En este caso
habrá que cambiar la definición cblock como se muestra a continuación.



cblock ; reserva cuatro bytes de memoria RAM, uno por cada dígito
unidades ;
decimas
centesimas
milesimas
digito5 ; añade un registro más de memoria RAM.
endc
2. La constante last_digit debe ser cambiada. Esta constante contiene la dirección de la
última variable del bloque cblock. En este caso la última variable es digit5.
last_digit set digit5
3. Ahora la constante, SIG_FIG debe ser igualada al número de dígitos deseados. Por
ejemplo, si se quieren cuatro dígitos a la derecha del punto decimal, un total de cinco
dígitos deberán ser obtenidos.
SIG_FIG equ 5
4. Se carga diez mil en el registro BARG, usando fprep.exe para encontrar el equivalente
de 10000 en coma flotante.

5.5.4.3 Resumen.

En este apartado se ha visto la conversión de números en formato coma flotante a ASCII. Esto
es útil para mostrar los resultados de alguna operación en coma flotante mediante la
utilización de displays. Un ejemplo de esta aplicación podría ser la lectura en un pin de una
entrada de entre 0.000 y 3.500 voltios, que mediante el convertidor analógico digital, muestra
el resultado en un LCD con números decimales.


Microcontroladores PIC de la Gama Media. A. Protocolo I2C.

Apéndice A: Protocolo I2C.

A.1 Introducción.

El bus I2C es un interface de comunicación serie que consta de dos hilos. En este protocolo
cada dispositivo tiene una dirección. Cuando un maestro quiera iniciar una transferencia de
datos, lo primero que transmitirá será la dirección del dispositivo con que se quiera
comunicar. Todos los dispositivos están atentos y comprueban si se trata de su dirección.
Dentro de esta dirección, el último bit especifica si el maestro quiere realizar una lectura o una
escritura sobre el esclavo. Durante una operación de transferencia de datos el maestro y el
esclavo están siempre en modos opuestos, uno en modo de transmisión y otro como receptor.
Indistintamente de quién reciba y quién transmita, la señal de reloj la genera el maestro.

Las líneas de salida de las señales de reloj (SCL) y datos (SDA) deben estar en drenador o
colector abierto, de modo que se pueda producir una Y cableada en el bus. Las resistencias
externas son usadas para asegurar un nivel alto cuando ningún dispositivo la pone a cero. El
número de dispositivos que se pueden conectar al bus I2C está limitado por la máxima carga
que puede tener el bus que es de 400 pF, y por la capacidad de direccionamiento.

A.2 Inicialización y fin de transferencia de datos.

Mientras no se realiza transferencia de datos, ambas líneas, la de reloj y la de datos, están en
estado alto debido a las resistencias pull-up externas. Las condiciones de START y STOP
determinan el inicio y el fin de las transmisiones de datos.

La condición de START se define como la transición de nivel alto a bajo de la línea SDA
cuando SCL está en alto. La condición de STOP se define como la transición de nivel bajo a
alto de la línea SDA estando en alto SCL. Esto es lo que ilustra la figura A.1.



Estas condiciones las genera el maestro. Debido a la definición de las condiciones de START
y STOP, cuando comienza la transmisión, la línea de datos SDA sólo puede cambiar de
estado cuando la línea SCL esté en bajo.

Figura A.1 Condiciones de Start y Stop.

A.3 Direccionamiento de dispositivos en I2C.

Existen dos formatos para el direccionamiento en el protocolo I2C. El más simple es el
formato de 7 bits de dirección con un bit de R/ W (figura A.2), y el otro, más complejo es de
10 bits de dirección y el bit de R/ W (figura A.3). Para este último formato deben transmitirse
dos bytes de dirección. Los primeros cinco bits indican que se trata de un direccionamiento de
10 bits. En la primera transmisión se envían estos cinco bits, los dos más significativos de la
dirección y el bit R/ W , quedando los otros ocho bits de la dirección para la segunda
transmisión.

Figura A.2 Formato de dirección de 7 bits.



Figura A.3 Formato de direccionamiento de 10 bits para el protocolo I2C.

A.4 Reconocimiento de transferencia.

Todos los datos deben ser transmitidos por bytes, sin límite en el número de bytes a transmitir
por cada transferencia de datos. Después de cada byte, el esclavo-receptor genera un bit de
reconocimiento ( ACK ) (figura A.4). Cuando el esclavo no manda este bit de reconocimiento,
el maestro debe abortar la transferencia, para ello el esclavo deja la línea SDA en alto para
que el maestro pueda generar la condición de STOP.

Figura A.4 Reconocimiento del esclavo-receptor.

Si es el maestro el que está recibiendo datos, es éste el que ha de generar el bit de
reconocimiento después de cada byte recibido, excepto para el último. En este caso, el
maestro no manda el bit de reconocimiento, liberando el esclavo la línea SDA para que el
maestro genere la condición de STOP. La condición de STOP, también la puede generar el
maestro durante el pulso del bit de reconocimiento, terminando así la transferencia.



Si el esclavo necesita retardo para la transmisión del siguiente byte, mantiene la línea SCL en
estado bajo, forzando al maestro a esperar. La transferencia de datos continua cuando el
esclavo libera la línea SCL. Esto permite al esclavo mover los datos recibidos o buscar los
nuevos datos a transmitir antes de que el reloj se active.

En las figuras A.5 y A.6 se muestran las secuencias de la transferencia de datos del maestro
como transmisor y receptor.

Figura A.5 Secuencia de maestro transmisor.



Figura A.6 Secuencia de maestro receptor.

Cuando el maestro no quiere abandonar el bus (cosa que ocurre cuando se genera una
condición de Stop), éste debe de generar una condición de START repetida (Sr). Es idéntica a
la condición de START explicada anteriormente, pero ocurre después de un pulso e
reconocimiento (no con el bus libre). Esto permite al maestro enviar “comandos” al esclavo y
recibir la información pedida o direccionar a distintos dispositivos esclavos.


Pic problemas resueltos

Más contenido relacionado

La actualidad más candente (20)

Similar a Pic problemas resueltos (20)

Último (20)

Pic problemas resueltos