pic gama-media

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:

[email protected]

Microcontroladores PIC de la Gama Media. ÍNDICE GENERAL.

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

I

Í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



II

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



III

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



IV

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

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


1

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.



2

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.



3

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.



4

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.



5

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.



6

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.



7

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

Mem

oria

de

prog

ram

a

Cáp

sula

s

Máx

ima

frec

uenc

ia d

e tra

bajo

EPR

OM

EER

OM

Mem

oria

de

dato

s (by

tes)

EEPR

OM

de

dato

s (by

tes)

Mód

ulos

de

tem

poriz

ació

n

Mód

ulos

CC

P

Puer

tos s

erie

Puer

to P

aral

elo

Con

verti

dor A

/D d

e 8

bits

Com

para

dore

s

Tens

ión

inte

rna

de re

fere

ncia

Fuen

tes d

e in

terr

upci

ón

Patil

las d

e E/

S

Ran

go d

e vo

ltaje

(vol

tios)

Det

ecto

r de

fallo

en

VD

D “

Bro

wn-

out”

Pine

s DIP

Pine

s PLC

C

Pine

s QFP

PIC16C61 20 1K --- 36 --- TMR0 -- --- -- -- -- -- 3 13 3,0-6,0 --- 18 18 --

PIC16C62 20 2K --- 128 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI -- -- -- -- 10 22 2,5-

6,0 --- 28 28 --

PIC16C63 20 4K --- 192 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI --- -- -- -- 10 22 3,0-

6,0 --- 28 28 --

PIC16C64 20 2K --- 128 --- TMR0,TMR1,TMR2 1 SPI/I2C Si -- -- -- 8 33 3,0-

6,0 --- 40 44 44

PIC16C65 20 4K --- 192 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI Si -- -- -- 11 33 3,0-

6,0 --- 40 44 44

PIC16C620 20 512 --- 80 --- TMR0 -- ---- -- -- 2 Si 4 13 3,0-6,0 Si 18 18 20

PIC16C621 20 1K --- 80 --- TMR0 -- ---- -- -- 2 Si 4 13 3,0-6,0 Si 18 18 20

PIC16C622 20 2K --- 128 --- TMR0 -- ---- -- -- 2 Si 4 13 3,0-6,0 Si 18 18 20

PIC16C71 20 1K --- 36 --- TMR0 -- ---- -- 4ch -- -- 4 13 3,0-6,0 --- 18 18 --

PIC16C73 20 4K --- 192 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI -- 5ch -- -- 11 22 3,0-

6,0 --- 28 28 --

PIC16C74 20 4K --- 192 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI Si 8ch -- -- 12 33 3,0-

6,0 --- 40 44 44

PIC16C76 20 8K --- 368 --- TMR0,TMR1,TMR2 2 SPI/I2C/SCI -- 5ch -- -- 11 22 2,5-

6,0 Si 28 28 --

PIC16C84 20 -- 1K 36 64 TMR0 -- ---- -- -- -- -- 4 13 3,0-6,0 --- 18 18 --

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.



8

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.



9

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


11

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.



12

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.



13

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.



14

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



15

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.



16

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.



17

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’.



18

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’.



19

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. 0 = Acarreo en la suma y no en la resta. bit 0 C: Acarreo en el 8º bit.

1 = Acarreo en la suma y no en la resta. 0 = Acarreo en la suma y no en la resta.

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.



20

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.



21

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 FOSC0bit13 bit0

bit 13-8 CP<1:0>: Bits de protección de código. 5-4: 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

512 1k 2k 11 Off Off Off 10 Off Off ½ alta On 01 Off ½ alta On ¾ alta On 00 On On On



22

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

configuración FOSC1:FOSC0

Modo OSC

Ganancia de los inversores internos Comentarios

11 RC −

Solución más barata (sólo requiere una resistencia y un condensador). Máxima variación del tiempo base. Modo del dispositivo por defecto

10 HS Ganancia alta Cristal de cuarzo para aplicaciones de alta frecuencia. Es el modo que más potencia consume de los tres cristales.

01 XT Ganancia media Cristal de cuarzo para un rango de frecuencias estándar.

00 LP Ganancia baja Cristal de cuarzo para aplicaciones de baja frecuencia. Es el modo que menos potencia consume de los tres cristales.



23

TABLA 2.2 Selección del modo de oscilación con FOSC2:FOSC0.

Bits de configuración

FOSC2:FOSC0

Modo OSC

Ganancia de los

inversores internos

Comentarios

111 EXTRC con CLKOUT −

Red RC externa sacando la señal de oscilación por la patilla CLKOUT. Solución barata. Máxima variación en el tiempo base. Modo del dispositivo por defecto

110 EXTRC − Red RC externa. Barata solución. Máxima variación en el tiempo base. La señal de oscilación no sale al exterior.

101 INTRC con CLKOUT −

Red RC interna sacando la señal de oscilación por la patilla CLKOUT. Es la solución más barata. Oscilador de 4MHz.

100 INTRC − Red RC interna. La señal de oscilación no sale al exterior. Solución más barata. Oscilador de 4MHz.

011 − − Reservado

10 HS Ganancia altaCristal de cuarzo para aplicaciones de alta frecuencia. Es el modo que más potencia consume de los tres cristales.

01 XT Ganancia media

Cristal de cuarzo para un rango de frecuencias estándar.

00 LP Ganancia baja

Cristal de cuarzo para aplicaciones de baja frecuencia. Es el modo que menos potencia consume de los tres 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.



24

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.



25

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.



26

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).



27

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.

TIEMPO DE POWER-UP CONFIGURACIÓN DEL OSCILADOR Habilitado Deshabilitado

BROWN-OUT RESET

WAKE-UP DESDE SLEEP

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.



28

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.



29

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).



30

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.



31

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:

V7.0R2R1

R1 VDD =+

•

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.



32

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.

Registro Power-On Reset Brown-Out Reset

MCLR durante: -funcionamiento normal -SLEEP WDT Reset

Wake-up desde SLEEP mediante: -Interrupciones -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



33

Registro Power-On Reset Brown-Out Reset

MCLR durante: -funcionamiento normal -SLEEP WDT Reset

Wake-up desde SLEEP mediante: -Interrupciones -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



34

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.



35

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

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.

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.



36

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.



37

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).



38

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.


39

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.



40

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.



41

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.

TOSC0 TOSC1 TOSC2 TOSC3 TOSC4 TOSC5

Buscar 1 Ejecutar 1 1. MOVLW 55h 2. MOVWF PORTB Buscar 2 Ejecutar 2 Buscar 3 Ejecutar 3 3. CALL SUB_1 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.



42

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.



43

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)

d Selección el destino; 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.



44

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

instrucción Nemónicos, Operandos Descripción Ciclos

MSb LSb

Bits de Estado

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



45

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 Flags afectados: C, DC, Z 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 Antes de la instrucción W = 0x17 FSR = 0xC2 Después de la instrucción W = 0xD9 FSR = 0xC2



46

ANDLW Y lógica entre Literal y W

Sintaxis: [etiqueta] ANDLW k Operandos: 0 ≤ k ≤ 255 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (W) AND (f) → dest Flags afectados: Z Código OP: 00 0101 dfff ffff 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



47

BCF Borra un bit

Sintaxis: [etiqueta] BCF f, b Operandos: 0 ≤ f ≤ 127

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 Operandos: 0 ≤ f ≤ 127

0 ≤ b ≤ 7 Operación: 1 → f<b> Flags afectados: Ninguno Código OP: 01 01bb bfff ffff 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



48

BTFSC Testeo de bit y salto si es 0

Sintaxis: [etiqueta] BTFSC f, b Operandos: 0 ≤ f ≤ 127

0 ≤ b ≤ 7 Operación: Salta si (f<b>) = 0 Flags afectados: Ninguno Código OP: 01 10bb bfff ffff 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 Operandos: 0 ≤ f ≤ 127

0 ≤ b ≤ 7 Operación: Salta si (f<b>) = 1 Flags afectados: Ninguno Código OP: 01 11bb bfff ffff 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



49

CALL Salto a subrutina

Sintaxis: [etiqueta] CALL k Operandos: 0 ≤ k ≤ 2047 Operación: (PC) + 1 → TOS,

k → PC<10:0>, (PCLATCH<4:3>) → PC<12:11>

Flags afectados: Ninguno 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 Operandos: 0 ≤ f ≤ 127 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



50

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



51

COMF Complementa el registro f

Sintaxis: [etiqueta] COMF f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: ( f ) → dest Flags afectados: Z Código OP: 00 1001 dfff ffff 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) - 1 → dest Flags afectados: Z Código OP: 00 0011 dfff ffff 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



52

DECFSZ Decrementa el registro f y salta si es 0

Sintaxis: [etiqueta] DECFSC f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) – 1 → dest; salta si el resultado es 0 Flags afectados: Ninguno Código OP: 00 1011 dfff ffff Descripción: Decrementa 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”. 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 Después de la instrucción CONT = 0x00 PC = dirección de CONTINUAR

GOTO Salto Incondicional

Sintaxis: [etiqueta] GOTO k Operandos: 0 ≤ k ≤ 2047 Operación: k → PC<10:0>

PCLATCH<4:3> → PC<12:11> Flags afectados: Ninguno 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



53

INCF Incrementa el registro f

Sintaxis: [etiqueta] INCF f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) + 1 → dest Flags afectados: Z Código OP: 00 1010 dfff ffff 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 Después de la instrucción CONT = 0x00 Z = 1

INCFSZ Incrementa el registro f y salta si es 0

Sintaxis: [etiqueta] INCFSC f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) + 1 → dest; salta si el resultado es 0 Flags afectados: Ninguno Código OP: 00 1111 dfff ffff Descripción: Incrementa 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”. 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 Después de la instrucción CONT = 0x00 PC = dirección de CONTINUAR



54

IORLW O lógica entre Literal y W

Sintaxis: [etiqueta] IORLW k Operandos: 0 ≤ k ≤ 255 Operación: (W) OR (k) → W Flags afectados: Z Código OP: 11 1000 kkkk kkkk 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (W) OR (f) → dest Flags afectados: Z Código OP: 00 0100 dfff ffff 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



55

MOVLW Mueve un Literal a W

Sintaxis: [etiqueta] MOVLW k Operandos: 0 ≤ k ≤ 255 Operación: k → W Flags afectados: Ninguno 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) → dest Flags afectados: Z Código OP: 00 1000 dfff ffff 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 Antes de la instrucción W = 0x00 FSR = 0xC2 Después de la instrucción W = 0xC2 Z = 0



56

MOVWF Mueve W al registro f

Sintaxis: [etiqueta] MOVWF f Operandos: 0 ≤ f ≤ 127 Operación: (W) → f Flags afectados: Ninguno 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 Flags afectados: Ninguno 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



57

RETFIE Retorno de rutina de interrupción

Sintaxis: [etiqueta] RETFIE Operandos: Ninguno Operación: TOS → PC

1 → GIE Flags afectados: Ninguno 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 Operandos: 0 ≤ k ≤ 255 Operación: k → W

TOS → PC Flags afectados: Ninguno 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 Antes de la instrucción W = 0x07 Después de la instrucción W = valor de k7 PC= TOS = dirección de PROGRAMA +1



58

RETURN Retorno de subrutina

Sintaxis: [etiqueta] RETURN Operandos: Ninguno Operación: TOS → PC Flags afectados: Ninguno 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: Rotación a la izquierda de f. Flags afectados: C Código OP: 00 1101 dfff ffff 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”.

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

Registro f C



59

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

Sintaxis: [etiqueta] RRF f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: Rotación a la derecha de f. Flags afectados: C Código OP: 00 1100 dfff ffff 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”.

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

Registro f C



60

SUBLW Resta W de un Literal

Sintaxis: [etiqueta] SUBLW k Operandos: 0 ≤ k ≤ 255 Operación: k – (W) → W Flags afectados: C, DC, Z 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 Antes de la instrucción W = 0x01 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 Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f) - (W) → dest Flags afectados: C, DC, Z Código OP: 00 0010 dfff ffff 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



61

SWAPF Intercambio de los Nibbles del registro f

Sintaxis: [etiqueta] SWAPF f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (f<3:0>) → dest<7:4>

(f<7:4>) → dest<3:0> Flags afectados: Ninguno Código OP: 00 1110 dfff ffff Descripción: Los cuatro bits más significativos y menos significativos del

registro “f”, son intercambiados entre si. Si “d” es 0, el resultado se almacena en el registro W, mientras que si es 1 se almacena en el registro “f”.

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 Operandos: 0 ≤ k ≤ 255 Operación: (W) XOR (k) → W Flags afectados: Z Código OP: 11 1010 kkkk kkkk 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)



62

XORWF O exclusiva entre W y el registro f

Sintaxis: [etiqueta] XORWF f, d Operandos: 0 ≤ f ≤ 127

d є [0, 1] Operación: (W) XOR (f) → dest Flags afectados: Z Código OP: 00 0110 dfff ffff 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.


63

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.



64

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



65

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.

R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 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.



66

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.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit SSPIE: Habilitación de interrupción del Puerto Serie Síncrono.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada.



67

bit RCIE: Habilitación de interrupción por recepción de la USART. 1 = Interrupción habilitada.

0 = Interrupción deshabilitada. bit TXIE: Habilitación de interrupción por transmisión de la USART.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit ADIE: Habilitación de interrupción por conversión A/D.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit ADCIE: Habilitación de interrupción en el convertidor de rampa A/D.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada.

bit OVFIE: Habilitación de interrupción por rebose del temporizador del convertidor de rampa A/D.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit PSPIE: Habilitación de interrupción por lectura/escritura del Puerto

Paralelo Esclavo. 1 = Habilitada interrupción por lectura/escritura del PSP.

0 = Interrupción deshabilitada. bit EEIE: Habilitación de interrupción por escritura en EEPROM.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit LCDIE: Habilitación de interrupción del LCD.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. bit CMIE: Habilitación de interrupción del comparador.

1 = Interrupción habilitada. 0 = Interrupción deshabilitada. 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.



68

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. No se utiliza en este modo. 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.



69

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. (Se borra por software).

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. (Se borra por software).

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).



70

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.



71

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.



72

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



73

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.



74

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’.



75

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.



76

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.



77

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.



78

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.



79

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).



80

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.



81

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.



82

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.



83

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

(Se borra por software). 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’.



84

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

bit 0 TRISE0: Bit de control de dirección del pin RE0. 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.



85

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.



86

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.



87

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. 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 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).



88

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.



89

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:

125.78256

1020visorValorPredi3

≈•

= (4.2)

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)



90

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:



91

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 SYNC1T 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. 10 = Valor del predivisor 1:4. 01 = Valor del predivisor 1:2. 00 = Valor del predivisor 1:1. 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.



92

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. 0001 = Valor del postdivisor 1:2. ....... ....... 1110 = Valor del postdivisor 1:15. 1111 = Valor del postdivisor 1:16. bit 2 TMR2ON: Activación del TMR2. 1 = TMR2 activado. 0 = TMR2 parado.



93

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

01 = Valor del predivisor 1:4. 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.



94

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.



95

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



96

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.



97

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.



98

Figura 4.24 Señal PWM.

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



99

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:

( ) bits2log

FFlogPWM

osc⎟⎠⎞

⎜⎝⎛

= Resolución (4.7)

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

Predivisor T2CKPS1:T2CHPS0 Mínima resolución (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.



100

Se desea un PWM con una frecuencia de 78.125 KHz, siendo FOSC= 20 MHz y el

predivisor del TMR2=1.

• [ ] 11020141)2(PR

KHz125.781

6 ••

••+=s

=> PR2 = 63. (4.8)

• ( )

( ) bits82log

10125.781020log

MáximaResolución3

6

=••

= (4.9)

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.



101

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



102

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 4 Bit no implementado: Se lee como ‘0’. 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.



103

É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. 0 = C1 VIN – se conecta a AN0. Cuando CM2:CM0 = 010: 1 = C1 VIN – se conecta a AN3. C2 VIN – se conecta a AN2. 0 = C1 VIN – se conecta a AN0. C2 VIN – se conecta a AN1. bits 3:0 CM2:CM0: Selección del modo del comparador. Ver figura 4.28.



104

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



105

á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.



106

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.



107

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:

R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 ADCS1 ADCS0 CHS2 CHS1 CHS0 GO/ DONE Reservado ADON

bit 7 bit 0



108

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.



109

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



110

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 2TOSC 00 100 ns(2) 400 ns(2) 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.



111

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.



112

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.



113

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.

R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 R/W-0 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.



114

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. 0001 = SPI, modo maestro, reloj = FOSC/16. 0010 = SPI, modo maestro, reloj = FOSC/64. 0011 = SPI, modo maestro, reloj = Salida del TMR2 /2. 0100 = SPI, modo esclavo, reloj = pin SCK, pin SShabilitado.

0101 = SPI, modo esclavo, reloj = pin SCK, pin SSdeshabilitado. 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.



115

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



116

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>).



117

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.



118

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).



119

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.



120

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.



121

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



122

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).



123

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).



124

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.



125

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.



126

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 3 Bit no implementado: Se lee como ‘0’. bit 2 BRGH: Selección de baudios de alta velocidad. Modo asíncrono:

1 = Alta velocidad. 0 = Baja velocidad. Modo Síncrono: No se utiliza en este modo.

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.



127

• 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 3 Bit no implementado: Se lee como ‘0’. 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.



128

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);

)1(x64FBaudios OSC

+•= (4.11)

o Alta velocidad (BRGH = 1);

)1(x16FBaudios OSC

+•= (4.12)

• Modo síncrono (SYNC = 0). o Baja velocidad (BRGH = 0);

)1(x4FBaudios OSC

+•= (4.13)

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:

;1)(x64

101696006

+••

= (4.14)

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,



129

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



130

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.



131

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



132

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.



133

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.



134

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.



135

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.


137

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.



138

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

_ _BADRAM Especifica las localizaciones inválidas de la RAM. _ _badram <expr>

BANKISEL Genera código para la selección del banco de RAM para un direccionamiento indirecto. bankisel <etiqueta>

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 Declara símbolos constantes. constant <etiqueta>[=<expr>,... ...,<etiqueta>[=<expr>]

DATA Crea datos numéricos y textos. [<etiqueta>]data<expr>[,<expr>,.., expr>][<etiqueta>]data“<cadena_de_texto>” [,“<cadena_de_texto>”, ...]

DB Declara datos de un byte. [<etiqueta>] db<expr>[,<expr>,...,<expr>][<etiqueta>] db“<texto>”[,“<texto>”,...]

DE Define datos EEPROM. [<etiqueta>] de<expr>[,<expr>,...,<expr>][<etiqueta>] de“<texto>”[,“<texto>”,...]

#DEFINE Define etiquetas. define <nombre> [<valor>] define <nombre> [<arg>,...,<arg>]<valor>

DT Define una tabla. [<etiqueta>] dt<expr>[,<expr>,...,<expr>] [<etiqueta>] dt“<texto>”[,“<texto>”,...]

DW Declara datos de una palabra. [<etiqueta>]dw<expr>[,<expr>,...,<expr>][<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>

IF Comienza un bloque de ensamblado de código condicional. if <expr>

IFDEF Ejecuta si el símbolo ha sido definido. ifdef <etiqueta> IFNDEF Ejecuta si el símbolo no ha sido definido. ifndef <etiqueta>

#INCLUDE Incluye archivos fuente adicionales. include <<archivo_include>> | “<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>



139

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

PAGESEL Genera el código para la selección de la página de ROM. pagesel <etiqueta>

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>]

UDATA_OVR Comienza una sección de datos no inicializados reutilizables. [<nombre>] udata_ovr [<dirección>]

UDATA_SHR Comienza una sección de datos no inicializados compartidos. [<nombre>] udata_shr [<dirección>]

#UNDEFINE Borra una etiqueta de substitución. #undefine <etiqueta>

VARIABLE Declara un símbolo variable. variable <etiqueta>[=<expr>, ..., <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.



140

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



141

• 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



142

• _ _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



143

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>.



144

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



145

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



146

• 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



147

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.



148

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>



149

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.



150

• 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:\sys\sysdefs.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.

f =<formato> INHX8M Fija el formato de salida del archivo hex, puede ser INHX32, INHX8M, o INHX8S.

free FIXED Uso de formato libre(parser). Proporciona compatibilidad con anteriores.

fixed FIXED Uso de formato fijo.

mm = ON | OFF On Imprime el mapa de memoria en el archivo del listado.

n = nnn 60 Fija las líneas por página.

p =<tipo> Ninguno Fija el tipo de procesador; por ejemplo, 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.



151

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.



152

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



153

• 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”



154

• 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>]



155

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



156

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



157

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.



158

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.



159

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.



160

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. ...



161

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.



162

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.

El listado del programa quedaría así: ... 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.



163

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.

El listado del programa quedaría así: ...

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



164

... ; 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.



165

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.



166

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.



167

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.



168

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.



169

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.



170

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)



171

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,



172

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



173

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.



174

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 e2·fx = , donde 1 ≤ f < 2, al calcular su raíz se utilizan las siguientes expresiones:

x = 2e

2 · f ,si e es par (5.13)

x = 2e

2 · 2 ·f , 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.

2/yfyy

00 ⎟⎟

⎠

⎞⎜⎜⎝

⎛+= (5.15)

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



175

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 = z1+ en el intervalo [0, 1] de z, se obtiene

la aproximación de la forma

z1+ = 1+ q(z)p(z)z , donde z ≡ f + 1. (5.16)

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:

znzn2lnxx ·2222e === + , (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.



176

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 znln2n zx e ·2ee == + , (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.



177

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:

( )flogn · 2ln xlog · 2ln ln x 22 +== , (5.23)

donde n es un número entero y 0.5 ≤ f <1. El valor de z)(1logflog 22 += se obtiene de la

representación de la función en los subintervalos de z [ 12

1− , 0] y [0, 12 − ], usando la

aproximación racional del mínimo de la forma

q(z)p(z)zz)(1log 2 ≈+ , (5.24)

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 n2 = ln f + n · ln 2, (5.25)

donde n es un número entero y 0.5 ≤ f <1. El valor de z)ln(1fln += se obtiene de la

representación de la función en los subintervalos de z [ 12

1− , 0] y [0, 12 − ], usando la

aproximación racional del mínimo de la forma

⎟⎟⎠

⎞⎜⎜⎝

⎛+−≈+

q(z)p(z) ·z zz · 0.5zz)ln(1 22 , (5.26)

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.



178

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.

ln x · e log xlog = (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;

LOOSTHR = π· 10242 · 4π 2

24= (5.29)

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 ⎥⎦⎤

⎢⎣⎡−

4π,

4π , mediante la siguiente definición:

z = x mod 4π , (5.30)

produciendo la primera evaluación de las relaciones ‘y’ y ‘j’.

y =4π

x , j = 8 · 8y ,

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



179

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 4π = x – y ·

4π = ((x – p1 · y) – p2 · y) – p3 · y , (5.31)

donde

4π = p1 + p2 + p3 , p1 ≈ 4

π y p2 ≈ 4π – p1 , (5.32)

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 ⎥⎦⎤

⎢⎣⎡−

4π,

4π se construye

de la siguiente forma:

sen x ≈ x + x · x2 · p(x2) (5.36)

cos x ≈ 1 – 0.5 ·x2 + x4 · q(x2) (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



180

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:

1x 0 ≡ , x ≥ 0

≡y0 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 · e2 , donde 0.5 ≤ f < 1. (5.41)

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



181

con el logaritmo en base 2 de x representado como

( ) ⎟⎠⎞

⎜⎝⎛ −

+++=⎟⎠⎞

⎜⎝⎛+==

aaf1logaloge

af · aloge2 · flogxlog 222

e22 , (5.43)

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 16k

k 2a −= , 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

v),(1log2 + 12 161 −− < v < 12 161 − . (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

( )⎟⎟⎠

⎞⎜⎜⎝

⎛+

−−=

−

kk

kk

k

k

BABAf

aaf , (5.46)

donde kkk BAa += . 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

( )q(v)p(v) ·v

2vvv1log 3

2

+−≈+ , (5.47)

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

v)(1log16kexlog 22 ++−= . (5.48)

Ahora el producto xlog ·y 2 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.



182

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: h-n/16ixlog ·y y 2 · 2 · 2 2 x 2 == , (5.49)

donde 2h es evaluada por la aproximación mínima de la forma

p(h) ·h h 12h +≈− , (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.



183

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:

c) x· (ax i1i +=+ mod m, (5.53)

con un multiplicador a, un incremento c, módulo m y un número inicial 0x . 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 = 322 (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 = 322 -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.



184

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.



185

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.


187

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.



188

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.



189

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.



190

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.



191

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 gama-media

Documents