1

Juan Ricardo Clavijo Mendoza

Projeto e simulao de
sistemas
microcontrolado em
Linguagem C
Programao com MikroC PRO
Proteus ISIS simulao
2



3




















Sandra, mi hijo Miguel, mis padres Jorge y Bibiana

Dedicado a minha esposa:
4

5






















Juan Ricardo Clavijo Mendoza


Projeto e simulao de
sistemas
microcontrolado em
Linguagem C
Programao com MikroC PRO compilador e
simulao no Proteus ISIS
6







































ISBN 978-958-44-8619-6
Primera edicin mayo de 2011
Projeto e simulao em linguagem C microcontrolado
A reproduo total ou parcial deste livro
qualquer meio, eletrnico ou mecnico,
sem o consentimento por escrito do autor.
Autor
Sr. Juan Ricardo Mendoza Clavijo
Reviso
Mr. Sandra Milena Bernate Batista
Dr. Duilio Cruz Becerra
7
Contenido















































1 MikroC Compiler e PIC ............................................ ..................................... 17
1.1 O compilador MikroC PRO .............................................. .............................................. 18
2 Fundamentos da linguagem C
2.1 Declarando variveis em C. ........................................... ............................... 20
2.2 Formatos numricos utilizados na linguagem C .......................................... ....................... 2
2.3 Operadores em linguagem C ............................................. .................................................. 2
2.4 Funes da linguagem
2,5 Criando um programa em linguagem C .......................................... ............................... 29
2.6 Condicionais e iteraes em C ............................................ .......................... 30
2.6.1 Criao de condies lgicas em C ........................................... ............ 30
2.6.2 A instruo condicional e se mais ........................................... .............................. 31
2.6.3 O caso switch .............................................. ............................................. 32
2.6.4 O ciclo iterativo tempo e fazer enquanto ........................................... ............................ 32
2.6.5 Ciclo iterativo
2.6.6 Ciclos iterativos usando nested ....................................... .................................. 33
3 O simulador Proteus ISIS ............................................. .................................................. 34 ..
3.1 Caractersticas bsicas do ISIS para simular ............................................ ...................... 35
4 Criando seu primeiro programa no MikroC PRO ........................................... ......................... 38
5 Exibir
5.1 Inverter 7
5.1.1 Tela de controle ............................................ 7 segmentos ............................... 45
5.1.2 Controle da dinmica ............................................ 7 exibe segmento ................. 47
5.2 Display LCD
5.2.1 Funes .............................................. caracteres imprimveis ........................... 54
5.2.2 Funes para imprimir cordas ............................................ ................... 55
5.2.3 Imprimindo valores numricos .............................................. ................................. 57
5.2.4 Criao de Personagem prprio .............................................. ................................... 59
5.3 Display LCD
6 Teclados e sistemas de entrada de dados ........................................... ..................................... 74
6.1 Usar
6.2 Usar
6.3 Usando o teclado da matriz .............................................. ............................................... 78
6.4 Usando teclados PS2 ou DIN ............................................ .................................................. 84
7 Comunicao Serial
7.1 Mdulo Serial
7.2 Mdulo USART
7.3 Mdulo
8 Converso AD e
8.1 Converso AD, ou
8.2 Converso DA ou
8.2.1 Converso DA com PWM .............................................. ....................................... 110
8.2.2 Converso DA R-2R sob ........................................... ............................... 114
9 EEPROM e memrias flash .............................................. .............................................. 117
9.1 EEPROM Memria
9.2 Memria
10 Mdulos timer
8















































14.7.1 Ejemplo de diseo oscilador doble cuadrado ......................................................... 225
14.7.2 Ejemplo de diseo para oscilador de acople en cuadratura .................................... 226
8
11 interrupies
12 sensores
12,1 LM35 sensor de temperatura .............................................................. 128
12.2 Sensores de preo
12,3 Sensores de distncia .......................................................................... 134
12,4 LDR Sensores __________________________________________138
12.5 Sensores de umidade e temperatura ............................................. ..... 141
13 Comunicao com
13.1 Mdulos GPS
13.2 Wireless Modules unidirecionais .................................. ...................... 161
13,3 Wireless Modules bidirecional ............................................... ........................ 167
13,4 RS 485 Comunicao ...................................................................................... 172
13,5 Mdulos sem fio infravermel......................................... ............................... 174
13,6 Comunicao com memria SD .................................................................... 177
13,7 Relogio de tempo real
14 Tratamento de sinais digitais
14.1 Sampling
14,2 Funes
14,3
14,4 Filtros FIR
14.4. 1 Low Pass Filter
14.4. 2 Filtros de passagem
14.4. 3 filtro passa-banda
14.4.4 Banda Rejeitar filtro ................................................................................... 195
14.4.5 multi Filtro
14.4.6 do Windows
14.4.7 janela retangular ............................................. ............................................ 197
14.4.8 do Windows
Hanning janelas 14.4.9
14.4.10 Windows
14,5 Exemplos de projeto do filtro FIR .................................................................. 202
14.5.1 Exemplo de design de baixo filtro de passagem para .................................. 204
14.5.2 Exemplo de design de alta filtro passa por ........................ ......................... 207
14.5.3 Exemplos de projeto do filtro passa-banda ........................ ....................... 208
14.5.4 Exemplo de banda rejeitam projeto do filtro ........................................ 209
14.5.5 Exemplo de projeto do filtro de multi banda ..................... ..................... 210
14,6 Filtros IIR ------------------------------------------------------------------------212
14.6.1 Transformao bilinear ........................................_________________213
14.6.1 Filtro bassa baixa IIR ........................................... 213
14.6.2 Low Pass filtro IIR ........................................... ................................. 213
14.6.3 Exemplo de design de baixo filtro de passagem para ............... ............. 215
14.6.4 High Pass Filter IIR------------------------------------------------------------216
14.6.5 Exemplo de design de alta filtro passa por ........................................ 217
14.6.6 IIR filtro passa-banda .................................................................... 219
14.6.7 Exemplo de projeto do filtro passa-banda ............ ....................... 220
14.6.8 Banda Rejeitar filtro IIR .............. ............................................ 221
14.6.9 Exemplo de banda rejeitam projeto do filtro .............................. 222
14,7 Osciladores
14.7.1 Exemplo de desenho duplo oscilador quadrado ................ 225
14.7.2 projeto de acoplamento para oscilador de quadratura------------ 226
9
14.8 Transformada discreta de Fourier DFT ...................................................................... 228
14.8.1 Transformada rpida de Fourier FFT ..................................................................... 232
14.9 Control digital PID ..................................................................................................... 238
15 Transmisin de datos ............................................................................................................ 243
15.1 Control de flujo .......................................................................................................... 244
15.2 Transparencia de datos ............................................................................................... 247
15.3 Control de errores CRC ............................................................................................. 252
16 Actuadores y potencia .......................................................................................................... 262
16.1 Actuadores DC ........................................................................................................... 262
16.1.1 Relevadores ............................................................................................................ 263
16.1.2 Motores DC ............................................................................................................ 264
16.1.3 Puente H ................................................................................................................. 265
16.1.4 Motores Paso .......................................................................................................... 267
16.1.5 Servomotores .......................................................................................................... 271
16.2 Actuadores AC ........................................................................................................... 273
17 Anexos .................................................................................................................................. 279
17.1 Tabla ASCII ............................................................................................................... 279
Bibliografa ................................................................................................................................... 281
ndice ............................................................................................................................................ 283



10
11
El autor
Juan Ricardo Clavijo Mendoza, Ingeniero Electrnico egresado de la universidad Manuela
Beltrn de Bogot D.C, Colombia. Autor de capitulo de libro de: Ciencia, tecnologa e
innovacin, Tomo 1, publicado por la Universidad Catlica de Colombia. Docente de la
Universidad Catlica de Colombia, en el programa de Tecnologa en Electrnica y
Telecomunicaciones, asesor temtico en proyectos de investigacin de la Universidad Catlica de
Colombia, y la Escuela de Telemtica de la Polica Nacional de Colombia, desarrollador de
proyectos tecnolgicos en diversas empresas de Bogot Colombia.
12
13
Prologo
El desarrollo de la tecnologa hace parte vital de la evolucin y el progreso de una nacin, est
razn motiva la creacin de documentos que formen a los desarrolladores e investigadores en las
diversas reas de la ciencia. Este libro busca hacer un aporte en este propsito como un curso de
fcil entendimiento en el diseo de sistemas microcontrolados, para este fin este texto se enfoca
en la simulacin de sistemas digitales en el paquete de software PROTEUS, y la programacin de
microcontroladores PIC con la herramienta de programacin en lenguaje C MikroC PRO. Este
libro es ideal para estudiantes de ingeniera, tecnologa, o carreras tcnicas en electrnica,
sistemas, mecatrnica, biomdica, y todas aquellas afines con la electrnica. De igual manera es
un aporte importante al desarrollo de proyectos de investigacin y tecnologa.
14
15
Introduccin
Este libro trata temticas relacionadas con el diseo de sistemas con microcontroladores, de la
familia microchip 12F, 16F, y 18F. Usando como herramienta de diseo, el compilador MikroC
PRO, y el paquete de software para simulacin Proteus. Para entender este libro de forma clara el
estudiante o desarrollador debe tener bases slidas de electrnica digital como circuitos
combinacionales y secuenciales. Tambin es de utilidad tener conocimientos bsicos de
programacin en lenguaje C y algoritmos. De la misma forma, se debe conocer las teoras de
circuitos elctricos, y circuitos electrnicos anlogos, teoras bsicas de algebra, y algebra lineal
as como la manipulacin de nmeros complejos en todas sus expresiones. Este libro se enfoca en
la demostracin de diseos simples que posteriormente pueden ser integrados para realizar
diseos de mayor complejidad en funcin de la necesidad del desarrollador.
16
17
1 El Compilador MikroC y los
PICMicro
Un microcontrolador es un dispositivo electrnico encapsulado en un circuito de alto nivel de
integracin. Los microcontroladores se pueden adquirir comercialmente de diferentes casas
fabricantes como: Freescale, Motorola, Intel, Philips, y Microchip.

Microchip en particular es una empresa fabricante de dispositivos electrnicos, en sus lneas de
produccin se encuentran los microcontroladores PICMicro, los cuales se pueden adquirir en
diferentes familias, algunas de ellas son: 12F, 16F, 18F, 24F, 30F, y 33F.

En funcin de la necesidad del proyecto el desarrollador debe escoger la familia y la referencia
que ms se acerque a su necesidad, por ejemplo el microcontrolador 12F675 es un PIC de 8 pines
con mdulos integrados bsicos como: Timer y ADC. Un microcontrolador como el 16F877
cuenta con 40 pines y mdulos como: Timer, ADC, USART, I2C, PWM, entre otros. Fcilmente
se pueden apreciar diferencias que permiten crear aplicaciones diferentes entre estos dos
ejemplos.


Figura 1-1

La informacin tcnica, la masiva comercializacin y la increble informacin publicada acerca
de los microcontroladores PIC, los hace ideales para aprender y estudiar su funcionamiento, la
empresa Microchip cuenta con el portal WEB www.microchip.com en donde se puede descargar
informacin y aplicativos de software que facilitan los desarrollos con sus microcontroladores.

Bsicamente implementar un desarrollo con un microcontrolador PIC consiste en identificar la
problemtica del desarrollo, crear editar y depurar un programa de mquina y programar
elctricamente el microcontrolador con un programador especifico para los PICMicro. Microchip
suministra programadores especializados en diferentes escalas, tal vez el ms popular es el
PICSTART Plus, sin embargo existen otros como el PICkit2, PICkit3. A pesar de que existan
programadores comerciales un desarrollador puede construir o adquirir un programador didctico
de bajo costo, de estos ltimos existe amplia informacin publicada en Internet.

18


Figura 1-2

Un microcontrolador tiene una arquitectura bsica que es similar a la de un computador de
escritorio, cuenta con un bloque de memoria OTP o Flash en la cual se guardan las instrucciones
del programa est seccin es similar al disco duro del computador, el PICMicro cuenta con una
memoria RAM, que cumple las mismas funciones de la memoria RAM de un ordenador personal,
el microcontrolador posee puertos de entrada y salida que son similares a los perifricos de
entrada y salida del computador tales como puertos para el ratn, impresora, monitor, teclado y
dems. Ests caractersticas hacen que un microcontrolador sea ideal para crear aplicaciones a
pequea escala que tengan interfaz de usuario, adecuando teclados, botones, lectura de memorias
de almacenamiento masivo, sensores de diversas variables como: temperatura, humedad, presin,
luminosidad, proximidad, entre otros. De igual manera, es posible crear ambientes de
visualizacin con displays numricos, alfanumricos y grficos. Los puertos seriales como la
USART y USB permiten crear comunicaciones seriales y comunicaciones inalmbricas con otros
dispositivos. En sntesis las posibilidades son infinitas.
1.1 El compilador MikroC PRO
La programacin de microcontroladores se basa en un cdigo de mquina que es conocido como
cdigo ensamblador, este cdigo contiene una a una las instrucciones del programa, este cdigo
ensamblador o tambin conocido como cdigo asembler es minucioso, y tedioso de editar. El
asembler crea cdigos de programa extensos y de difcil comprensin. La creacin de
compiladores de alto nivel facilit la edicin y creacin de programas en todo modo de
programacin lgica, por supuesto los microcontroladores no fueron la excepcin,
comercialmente existen varios compiladores de diferentes fabricantes y diferentes lenguajes de
alto nivel.

Es posible adquirir compiladores como el PICC, CCS, PIC Basic, entre otros. El estudio de este
libro se centra en el compilador MikroC PRO, que es un compilador en lenguaje C para
microcontroladores PICMicro de la familia 12F, 16F, y 18F.

MikroC PRO es un paquete de software con una amplia variedad de ayudas y herramientas que
facilita la creacin de proyectos y aplicativos para los microcontroladores PICMicro.

El estudio de este entorno de desarrollo es posible debido a que el estudiante puede descargar una
versin demo o estudiantil, que tiene las mismas caractersticas de la versin completa, la nica
limitacin es la dimensin del cdigo de mquina que no puede exceder 2K bytes, sin embargo es
una capacidad suficiente al tratarse de un prime aprendizaje. La versin demo se puede descargar
de la pagina: www.mikroe.com.
19
En la siguiente figura se puede apreciar la apariencia visual del entorno de desarrollo.


Figura 1-3

El compilador de alto nivel en lenguaje C utiliza estructuras que facilitan la programacin,
optimiza las operaciones matemticas y los procesos, por medio del uso de funciones
predefinidas y las no predefinidas que el desarrollador puede crear, as como el uso de un
conjunto de variables, de tipo carcter, entero, y punto decimal. El compilador crea
automticamente el cdigo ensamblador y a su vez un cdigo similar consignado en un archivo
con extensin *.hex, este archivo es el resultado primordial del compilador dado que con este se
programa elctricamente el microcontrolador o con el mismo se puede realizar una simulacin
computacional.
20
2 Fundamentos de lenguaje C
El lenguaje C data del ao 1972; fue creado por los laboratorios Bell como resultado de la
necesidad de reescribir los sistemas operativos UNIX con el fin de optimizar el conocido cdigo
ensamblador. De igual manera el lenguaje C fue la evolucin de lenguajes previos llamados B, y
BCPL. El nuevo lenguaje C, rpidamente tom fuerza por su funcionalidad y facilidad en la
implementacin en diversos sistemas computacionales que requeran cdigos de mquina.

La forma del lenguaje C, se fundamenta en un complejo estructural que requiere un amplio
estudio de las mismas, sin embargo para la programacin de los microcontroladores el estudiante
requiere una porcin fundamental que le permita iniciar y crear los primeros proyectos en
MikroC PRO, para este fin el actual captulo se centra en conocer las nociones necesarias para
iniciar el estudio de los microcontroladores con este libro.
2.1 Declaracin de variables en lenguaje C
Las variables bsicas en este compilador especfico son:
- bit
- char
- short
- int
- long
- float
- double

Las variables bit permiten almacenar un valor lgico es decir verdadero o falso, 0 1.

Las variables char se utilizan para almacenar caracteres codificados con el cdigo ASCII, son
tiles para guardar letras o textos.

Una variable short almacena un nmero entero de 8 bits corto puede valer de: -127 a 127.

Las variables tipo int guardan nmeros enteros de 16 bits, est variable permite guardar nmeros
de: -32767 a 32767.

La variable tipo long almacena nmeros enteros largos de 32 bits, su rango puede ser de:
-2147483647 a 2147483647.

Las variables tipo float y double permiten guardar nmeros con punto decimal.

Las anteriores variables pueden declararse incluyendo el signo positivo y negativo, o se pueden
declarar por medio de la opcin sin signo con la directriz unsigned.

21
En la siguiente tabla se pueden apreciar las caractersticas de las variables.

Tipo de variable Tamao en Bytes Valores que soporta
bit 1 0 1
char 1 -127 a 127
short 1 -127 a 127
int 2 - 32767 a 32767
long 4 - 2147483647 a 2147483647
float 4 -1.5x10^45 a 3.4x10^38
double 4 -1.5x10^45 a 3.4x10^38
unsigned char 1 0 a 255
unsigned short 1 0 a 255
unsigned int 2 0 a 65535
unsigned long 4 0 a 4294967295

Tabla 2-1

La declaracin de variables se realiza indicando el tipo de variable seguido de un nombre que el
desarrollador asigna arbitrariamente a la variable. En el punto de la declaracin de una variable es
posible dar un valor inicial a cada una de las variables sin embargo este ltimo no es
estrictamente necesario. Por ltimo la declaracin debe culminar con el carcter punto y coma (;).

En los siguientes ejemplos se puede apreciar como se hacen las declaraciones:

bit VARIABLE1_BIT; //Declaracin de una variable tipo bit.
char CARACTER; //Declaracin de una variable tipo char.
char CARACTER2='J'; //Declaracin de una variable tipo char inicializada con el
//valor ASCII del carcter J.
int ENTERO=1234; //Declaracin de una variable tipo entera inicializada con
//el valor 1234.
float DECIMAL=-12.45; //Declaracin de una variable con punto decimal
//inicializada con el valor -12,45.
double DECIMAL2=56.68; //Declaracin de una variable con punto decimal
//inicializada con el valor 56,68.
long ENTERO2=-954261; //Demacracin de una variable de tipo entero largo
//inicializada con el valor -954261.

Los siguientes ejemplos muestras como declarar variables sin signo:

unsigned char CARACTER; //Declaracin de una variable tipo char sin signo.
unsigned int ENTERO; //Declaracin de una variable tipo entera sin signo.
unsigned long ENTERO2; //Demacracin de una variable de tipo entero largo sin signo.

Las variables tambin pueden ser declaradas en un formato que asocia varias variables a un
mismo nombre, este formato se conoce como una cadena de variables, o un vector e incluso
puede ser una matriz de variables, en conclusin este tipo de declaraciones pueden ser de una o
ms dimensiones.

22
El siguiente ejemplo muestra un vector de caracteres, o tambin conocido como una cadena de
caracteres:

char Texto[20]; //Cadena de caracteres con 20 posiciones de memoria.

De igual manera las cadenas de caracteres o de variables pueden ser declaradas con un valor
inicial, este tipo de declaracin se puede ver en el siguiente ejemplo:

char Texto[20] = Nuevo Texto; //Declaracin de una cadena de caracteres
//inicializada con el texto: Nuevo Texto.
int Enteros[5]={5,4,3,2,1}; //Declaracin de una cadena de enteros con
//valores iniciales.
float Decimales[3]={0.8,1.5,5.8}; //Declaracin de una cadena de nmeros con
//punto decimal inicializadas.

La declaracin de las variables debe respetar algunas reglas bsicas que evitan errores y
contradicciones en la compilacin del cdigo, para este fin tenga presente las siguientes
recomendaciones:

- Las variables no deben tener nombres repetidos.
- Las variables no deben empezar por un nmero.
- Una variable no puede utilizar caracteres especiales como: / * ; { }-\! % &.

A continuacin se muestran ejemplos de declaraciones de variables que no se pueden hacer:

bit 1_VARIABLE-;
char -CARCTER!;
int 3ENTERO*;

De igual manera es posible crear estructuras de informacin como un nuevo tipo de variable
creada por el desarrollador. Ests estructuras se pueden realizar con las variables ya predefinidas
y pueden ser declaraciones de variables o de arreglos de variables. Este tipo de estructuras se
declarar, por medio de la directriz: typedef struct, y la forma de declarar una variable creada por
el desarrollador es la siguiente:

typedef struct
{
char Nombre[10];
int Edad;
}Usuario;

La siguiente es la forma de usar una variable personalizada por el desarrollador:

Usuario U;
U.Edad = 25;
U.Nombre[0]=J;
U.Nombre[1]=u;
U.Nombre[2]=a;
23
U.Nombre[3]=n;
U.Nombre[4]=0;
2.2 Formatos numricos usados en el lenguaje C
Los aplicativos en lenguaje C usan nmeros en diferentes bases numricas, a pesar de que para el
trabajo de bajo nivel del microcontrolador todos sus nmeros estn procesados en base 2 es decir
en nmeros binarios. El ser humano no est acostumbrado a pensar y procesar operaciones en
est base numrica. Desde las primeras etapas de la formacin acadmica las escuelas y colegios
ensean a pensar y procesar todos los clculos en base 10, es decir con nmeros decimales. Es
por esto que los compiladores en lenguaje C trabajan los nmeros decimales facilitando los
diseos para el desarrollador. Adems del sistema decimal el compilador en lenguaje C puede
trabajar otras bases tales como el binario, y hexadecimal haciendo ms simple realizar clculos y
tareas que en decimal seran ms complejas. Los sistemas numricos en base 2, 10, y 16, son los
implementados en este compilador en lenguaje C. La escritura de nmeros decimales, es la forma
de mayor simplicidad ya que se escriben en lenguaje C de la misma manera convencional que se
aprende desde los primeros cursos de matemticas. Los nmeros binarios se escriben con el
encabezado 0b seguidos del nmero en binario, un ejemplo de est escritura es: 0b10100001 que
es equivalente al nmero decimal 161. Los nmeros en base 16 o hexadecimales se denotan con
el encabezado 0x precedidos de un nmero en hexadecimal, la expresin 0x2A, es un ejemplo de
un nmero hexadecimal en lenguaje C, y equivale a 42 en decimal. Los nmeros binarios solo
pueden tener dos dgitos que son el 0 y el 1. Los nmeros hexadecimales pueden tener 16 dgitos
que son; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F.
2.3 Operadores en lenguaje C
El lenguaje C permite hacer operaciones aritmticas o matemticas bsicas entre nmeros
contenidos en variables o constantes. Las operaciones aritmticas disponibles son las siguientes:

- Suma
- Rest
- Multiplicacin
- Divisin
- Modulo

La suma aritmtica entre dos o ms nmeros, se puede hacer como se ve en el siguiente ejemplo:
int A;
int B;
int C;
C = A+B; //Est expresin guarda la suma de A y B en la variable C.
C = A+B+C; //Est expresin guarda la suma de A, B y C en la variable C.

La rest aritmtica entre dos o ms nmeros, se puede hacer como se ve en el siguiente ejemplo:
int A;
int B;
int C;
C = A-B; //Est expresin guarda la diferencia entre A y B en la variable C.
C = A-B-C; //Est expresin guarda la diferencia entre A, B y C en la variable C.

24
La operacin matemtica de multiplicacin se puede realizar entre dos o ms nmeros, la
operacin se relaciona con el carcter asterisco (*), est expresin se puede apreciar con mayor
claridad en los siguientes ejemplos:
int A;
int B;
int C;
C = A*B; //Est expresin guarda la multiplicacin entre A y B en la variable C.
C = A*B*C; //Est expresin guarda la multiplicacin entre A, B y C en la variable C.

La divisin aritmtica en lenguaje C se especifica por medio de la barra inclinada (/), en el
siguiente ejemplo se puede observar su implementacin:
int A;
int B;
int C;
C = A/B; //Est expresin guarda la divisin A entre B en la variable C.

La operacin mdulo calcula el mdulo de una divisin aritmtica es decir calcula el residuo de
una divisin, el clculo del mdulo se denota con el carcter de porcentaje, (%), la aplicacin de
est operacin se puede ver en el siguiente ejemplo:
int A;
int B;
int C;
C = A%B; //Est expresin guarda el residuo de la divisin de A entre B en la variable C.

Las operaciones aritmticas pueden ser usadas en forma combinada, es decir que se pueden
mezclar varias operaciones en una misma expresin, para ver esto con mayor claridad observe los
siguientes ejemplos:
int A;
int B;
int C;

C = (A+B)/C; //Est expresin es equivalente a C = (A+B)C.
C = (A/B)*C; // Est expresin es equivalente a C = (AB) X C.

Otros operadores matemticos abreviados pueden ser utilizados cuando se requiere de conteos o
cambios de una variable de forma constante, por ejemplo es posible incrementar o decrementar
una variable en trminos de un nmero, de igual manera es posible hacer est operacin con la
multiplicacin y la divisin. Para entender de forma ms clara este concepto observe los
siguientes ejemplos:

int A=100;
int B=10;

A++; //Este operador incrementa en una unidad el valor de A.
A--; //Este operador decrementa en una unidad el valor de A.
A+=4; //Este operador incrementa en 4 el valor de A.
A-=5; //Este operador decrementa en 5 el valor de A.
A/=4; //Este operador divide el valor de A en 4.
A*=3; //Este operador multiplica el valor de A por 3.
25
A+=B; //Este operador incrementa el valor de A en el valor de B unidades.
A*=B; //Este operador multiplica el valor de A por B veces.


Otras operaciones matemticas de mayor complejidad se pueden realizar en lenguaje C, por
medio de funciones predefinidas en la librera math, est temtica ser tratada posteriormente
cuando se estudie el uso y declaracin de funciones.
Los operadores lgicos permiten realizar acciones u operaciones que respetan la lgica digital
planteada por el matemtico ingls George Boole, en el siglo XIX. Boole plante las operaciones
OR, AND, NOT, XOR, NOR, NAND, XNOR, Ests operaciones son ampliamente estudiadas en
los cursos de sistemas digitales combinacionales y secuenciales.

Las operaciones lgicas se realizan en lenguaje C entre dos variables o constantes, ests se hacen
bit a bit, del mismo peso en una variable o nmero. Para ver y entender los ejemplos recuerde
primero las tablas de verdad de las operaciones lgicas que se muestran a continuacin:


Inversor NOT
Entrada Salida
0 1
1 0


OR inclusiva
Entrada 1 Entrada 2 Salida
0 0 0
0 1 1
1 0 1
1 1 1

OR exclusiva o XOR
Entrada 1 Entrada 2 Salida
0 0 0
0 1 1
1 0 1
1 1 0

AND
Entrada 1 Entrada 2 Salida
0 0 0
0 1 0
1 0 0
1 1 1



NOR inclusiva
Entrada 1 Entrada 2 Salida
0 0 1
0 1 0
1 0 0
1 1 0

NOR exclusiva o XNOR
Entrada 1 Entrada 2 Salida
0 0 1
0 1 0
1 0 0
1 1 1

NAND
Entrada 1 Entrada 2 Salida
0 0 1
0 1 1
1 0 1
1 1 0
26
Las operaciones lgicas en lenguaje C, se realizan con caracteres especficos, que denotan cada
una de ellas, en el siguiente ejemplo pueden verse las aplicaciones de los operadores lgicos:

Operacin lgica NOT, negacin, se denota con el carcter virgulilla (~);
unsigned short VALOR1=0b01010000; //Variable inicializada en binario con el nmero 80.
unsigned short RESULTADO;
RESULTADO = ~VALOR1; //La variable RESULTADO guarda el complemento de
//VALOR1, 175.

Operacin lgica OR, o inclusiva, est se denota con el carcter barra vertical (|);
unsigned short VALOR1=0b01010000; //Variable inicializada en binario con el nmero 80.
unsigned short VALOR2=0b01011111; //Variable inicializada en binario con el nmero 95.
unsigned short RESULTADO;
RESULTADO = VALOR1|VALOR2; //El valor de la operacin lgica o, es guardado en
//RESULTADO, 95.

Operacin lgica XOR, o exclusiva, est se denota con el carcter acento circunflejo (^);
unsigned short VALOR1=0b01010000; //Variable inicializada en binario con el nmero 80.
unsigned short VALOR2=0b01011111; //Variable inicializada en binario con el nmero 95.
unsigned short RESULTADO;
RESULTADO = VALOR1^VALOR2; //El valor de la operacin lgica AND
//es guardado en RESULTADO, 15.

Operacin lgica AND, y, est se denota con el carcter ampersand (&);
unsigned short VALOR1=0b01010000; //Variable inicializada en binario con el nmero 80.
unsigned short VALOR2=0b01011111; //Variable inicializada en binario con el nmero 95.
unsigned short RESULTADO;
RESULTADO = VALOR1&VALOR2; //El valor de la operacin lgica o
//exclusiva, es guardado en RESULTADO, 80.

La implementacin de las operaciones lgicas NAND, NOR, XNOR, son similares a AND, OR,
y XOR, a agregando el carcter de negacin virgulilla, observe los siguieres ejemplos:

unsigned short VALOR1=0b01010000; //Variable inicializada en binario con el nmero 80.
unsigned short VALOR2=0b01011111; //Variable inicializada en binario con el nmero 95.
unsigned short RESULTADO;
RESULTADO = ~(VALOR1|VALOR2); //El valor de la operacin lgica o negada
// exclusiva, es guardado en RESULTADO.
RESULTADO = ~(VALOR1&VALOR2); //El valor de la operacin lgica y negada,
// es guardado en RESULTADO.
RESULTADO = ~(VALOR1^VALOR2); //El valor de la operacin lgica o negada
// exclusiva negada, es guardado en RESULTADO.

El desplazamiento de bits dentro de una variable es til para realizar procesos y tareas que
impliquen la manipulacin de datos a nivel de los bits. El corrimiento a la derecha en una
variable o valor constante, en lenguaje C se realiza por medio del doble carcter mayor que, (>>),
de la misma manera el corrimiento a la izquierda se ejecuta con el doble carcter menor que,
(<<). La operacin de corrimiento hace perder los valores de los bits que salen, e ingresa ceros en
27
los nuevos bits. En los siguientes ejemplos se puede observar la implementacin de estos
operadores:
short Dato=0xFF; //Declaracin de variables.
short Resultado;
Resultado = Dato>>4; //Est operacin guarda en la variable Resultado el corrimiento de 4 bits
//a la derecha de la variable Dato, valor final de Resultado es 0x0F.
Resultado = Dato<<4; //Est operacin guarda en la variable Resultado el corrimiento de 4 bits
//a la izquierda de la variable Dato, valor final de Resultado es 0xF0.

En la siguiente tabla se resumen las operaciones lgicas y aritmticas contempladas
anteriormente:

Descripcin de la operacin Operador
Suma +
Rest -
Divisin /
Mdulo o residuo de la divisin entera %
Incremento ++
Decremento --
Operacin OR |
Operacin AND &
Operacin XOR ^
Complemento a 1 ~
Corrimiento a la derecha >>
Corrimiento a la izquierda <<

Tabla 2-2
2.4 Funciones en lenguaje C
Una funcin es una fraccin de cdigo que realiza una tarea especfica cada vez que est es
invocada por el flujo del programa principal. Las funciones cuentan con dos caractersticas
fundamentales, uno o ms parmetros de entrada, y un parmetro de salida. Cualquiera de ests
dos caractersticas puede ser una variable o un arreglo de ellas, de igual manera estos parmetros
de entrada y salida pueden ser vacos.

La estructura de las funciones se puede apreciar en los siguientes ejemplos:

void Funcion ( void ) //Funcin con parmetros de entrada y salida vacos.
{ // Apertura de la funcin con corchete.
//Porcin de cdigo donde se ejecutan la rutina de la funcin.
} //Cierre de la funcin con corchete.

void Funcion ( int A ) //Funcin con un parmetro de entrada y salida vaca.
{ // Apertura de la funcin con corchete.
//Porcin de cdigo donde se ejecutan la rutina de la funcin.
} //Cierre de la funcin con corchete.

28
int Funcion ( void ) //Funcin con parmetro de entrada vaco y salida entera.
{ // Apertura de la funcin con corchete.
//Porcin de cdigo donde se ejecutan la rutina de la funcin.
} //Cierre de la funcin con corchete.

int Funcion ( int A ) //Funcin con un parmetro de entrada y salida enteras.
{ // Apertura de la funcin con corchete.
//Porcin de cdigo donde se ejecutan la rutina de la funcin.
} //Cierre de la funcin con corchete.

Los nombres que se designan a las funciones cumplen con las mismas reglas para nombrar las
variables. El siguiente ejemplo muestra una funcin que es capaz de calcular el producto de dos
nmeros con punto decimal:

float Producto ( float A, flota B ) //Funcin para calcular el producto de A y B.
{ // Apertura de la funcin con corchete.
float RESULTADO;
RESULTADO = A*B; //Producto de A y B.
return RESULTADO; //La funcin retorna el resultado guardado en RESULTADO.
} //Cierre de la funcin con corchete.

Una funcin puede recurrir a otra funcin para realizar funciones ms complejas, para demostrar
est situacin se puede ver el siguiente ejemplo, que realiza el clculo del rea de una
circunferencia en funcin de su radio:


Figura 2-1

El rea de la circunferencia se calcula por medio de la ecuacin A=r, donde el valor de es
aproximadamente 3,1416.

float Valor_PI ( void ) //Funcin que retorna el valor de .
{ // Apertura de la funcin con corchete.
float PI=3.1416;
return PI;
} //Cierre de la funcin con corchete.

En el caso en que una funcin requiera variables internas est declaracin se debe hacer al
principio de la misma, antes de realizar cualquier otra accin o instruccin.

float Area_Circunferencia ( float Radio ) //Funcin para calcular el rea del circulo.
{ // Apertura de la funcin con corchete.
float Area;
29
Area = Valor_PI()*Radio*Radio; //Clculo del rea del circulo.
return Area;
} //Cierre de la funcin con corchete.

Las funciones son creadas por el desarrollador, sin embargo existen algunas que estn
predefinidas en el compilador y pueden ser consultadas e implementadas respetando los
parmetros de entrada y salida, la ms importante de ellas es la funcin main o principal. La
importancia de est funcin radica en el hecho de que es sobre ella que corre todo el programa
del microcontrolador y est se ejecuta automticamente cuando el microcontrolador se energiza.
La funcin main en el caso particular de los microcontroladores no contiene parmetros de
entrada ni de salida, su declaracin se puede apreciar en el siguiente ejemplo:

void main( void ) //Declaracin de la funcin main.
{ // Apertura de la funcin main.
//Cdigo del programa principal del microcontrolador.
} //Cierre de la funcin main.

Las declaraciones de funciones hechas por el desarrollador deben ser declaradas antes de la
funcin main, y en el caso de una funcin que invoque a otra funcin debe ser declarada antes de
la funcin que hace el llamado.

Las funciones matemticas trigonomtricas y otras como logaritmos, exponenciales, y
potenciacin pueden ser usadas con la librera predefinida por el compilador. Est librera se
denomina C_Math.
2.5 Creacin de un programa en lenguaje C
La estructura de un programa en lenguaje C es relativamente simple, primero es indispensable
declarar las variables globales que el desarrollador considere necesarias para el funcionamiento
del programa, ests variables globales son reconocidas por todos los puntos de cdigo del
programa incluidas las funciones propias del desarrollador y la funcin main. El paso a seguir es
hacer las declaraciones de funciones diseadas por el desarrollador para las tareas especficas en
su programa. Posteriormente se declara la funcin main y al comienzo de est se deben declarar
las variables que se requieran dentro de la misma. El cdigo que sigue debe configurar e
inicializar los puertos y mdulos del microcontrolador que sean indispensables en la aplicacin.
Por ltimo se edita el cdigo que contiene el aplicativo concreto del programa. En el siguiente
ejemplo se puede ver cmo hacer una estructura para un programa:

int Varible1; //Declaracin de variables globales.
char Variable2;
float Variable3;

//Declaracin de funciones propias del desarrollador.
float Valor_PI ( void )
{
float PI=3.1416;
return PI;
}

30
float Calculo_Area_Circulo( float Radio )
{
float Area;
Area = Valor_PI()*Radio*Radio; //Clculo del rea.
return Area;
}

void main( void ) //Declaracin de la funcin main o principal
{
float Valor_Radio; //Declaracin de variables de la funcin main.
float Valor_Area;
TRISB=0; //Configuracin de puertos y mdulos.
TRISC=0;
PORTB=0;
PORTC=0;
while( 1 ) //Cdigo concreto del aplicativo.
{
Valor_Area=Calculo_Area_Circulo( Valor_Radio );
}
}
2.6 Condicionales e iteraciones en lenguaje C
Las formas condicionales e iterativas hacen parte vital de las estructuras de cualquier cdigo en
lenguaje C. Ests permiten hacer ciclos en funcin de conteos y condiciones de variables que
hacen efectivo el flujo del programa. Las sentencias condicionales if, if else, y switch case,
permiten realizar mens, tomar decisiones, y controlar el flujo del programa o aplicativo. Las
estructuras iterativas while, do while y for, permiten crear bucles iterativos, que cuentan o
gobiernan tareas y procesos desarrollados en el programa.
2.6.1 Creacin de condiciones lgicas en lenguaje C
Las condiciones lgicas permiten tomar decisiones en funcin de una evaluacin. Las
condiciones lgicas solo retornan dos posibles valores: falso o verdadero. Cuando la condicin
lgica se hace directamente sobre una variable o nmero, la condicin es falsa cuando su valor es
0 y retorna verdadero para cualquier otro valor diferente de 0. Las formas condicionales usadas
en lenguaje C son: NOT, o negacin, OR o o inclusiva, AND o y. Tambin se pueden usar
comparaciones de magnitud entre dos valores tales como: mayor que, menor que, mayor o igual
que, menor o igual que, diferente que, e igual que. El uso de la negacin se realiza con el carcter
admiracin (!), la condicin OR, se realiza con los caracteres doble barra vertical (||), la condicin
AND o y, se usa con los caracteres doble ampersand (&&), la condicin mayor que se usa con el
carcter que tiene su mismo nombre (>), la condicin menor que, se hace con el carcter menor
que (<), la condicin mayor o igual que, se realiza con los caracteres mayor que, e igual (>=), la
condicin menor que, se realiza con los caracteres menor que, e igual (<=), la condicin de
igualdad se hace con los caracteres doble igual (==), y la condicin diferente que, se usa con los
caracteres de igualdad y admiracin (!=). Para entender con claridad estos operadores observe y
analice los siguientes ejemplos:

short A;
31
short B;
//La condicin es verdadera si A vale 10 y B vale 20.
(A==10)&&(B==20)
//La condicin es verdadera si A es diferente de 5 y B es mayor que 2.
(A!=5)&&(B>2)
//La condicin es verdadera si A es menor o igual que 4 o si B es mayor o igual que 6.
(A<=4)&&(B>=6)
//La condicin es verdadera si A no es mayor que 3 y si B es diferente de 4.
!(A>3)&&(B!=4)
2.6.2 La sentencia condicional if e if else
La estructura de la sentencia if evala una condicin lgica y ejecuta una porcin de cdigo si y
solo si el resultado de la evaluacin es verdadera. Observe la estructura del la sentencia if en el
siguiente ejemplo:

short Valor;
if( Valor>100 ) //Este if evala si la variable Valor es mayor que 100.
{
// Porcin de cdigo que se ejecuta si el if es verdadero.
}

La estructura if else es igual que la sentencia if, su nica diferencia es que en el dado caso de que
la evaluacin de la condicin sea falsa se ejecuta la porcin de cdigo asociada al else. Para
entender est situacin observe el siguiente ejemplo:

short Valor;
if( Valor>100 ) //Este if evala si la variable Valor es mayor que 100.
{
// Porcin de cdigo que se ejecuta si la condicin del if es verdadero.
}
else
{
// Porcin de cdigo que se ejecuta si la condicin del if es falsa.
}

Las sentencias if e if else se pueden anidar para crear estructuras ms completas y complejas, est
caracterstica se puede ver con claridad en el siguiente ejemplo:

short Valor1; //Declaracin de variables.
short Valor2;
if( Valor1>30 ) //Sentencia if.
{
// Cdigo que se ejecuta cuando el primer if tiene una condicin verdadera.
if( (Valor2==4)&&(Valor1<50) ) //Segunda sentencia if anidad.
{
//Cdigo que se ejecuta cuando el segando if tiene una condicin verdadera.
}
}
32
2.6.3 La sentencia switch case
La sentencia switch case, funciona de manera similar a la sentencia if, difiere en que no se evala
una condicin si no el valor de una variable, y ejecuta una porcin de cdigo para cada valor
posible de la variable. Los valores contemplados en los casos o case posibles de la variable los
escoge el desarrollador arbitrariamente en funcin de su criterio y necesidad. Los casos o valores
que no son de inters para el desarrollador se ejecutan en un fragmento de cdigo por defecto, por
medio de la directriz default. Cada uno de los fragmentos de cdigo editados deben terminar con
la directriz break para romper el flujo de la estructura switch case, est accin es necesaria dado
que si dos casos estn seguidos los fragmentos de cdigo seguidos se ejecutarn hasta encontrar
la directriz break o hasta finalizar la estructura switch case. Para comprender de forma clara el
funcionamiento de la sentencia switch case observe el siguiente ejemplo:

short Valor;
switch( Valor ) //Evaluacin de la variable Valor.
{
case 0: //Fragmento de cdigo correspondiente al valor 0 de la variable Valor.
break; //Ruptura del caso 0.
case 1: //Fragmento de cdigo correspondiente al valor 1 de la variable Valor.
break; //Ruptura del caso 1.
case 10: //Fragmento de cdigo correspondiente al valor 10 de la variable Valor.
break; //Ruptura del caso 10.
case 20: //Fragmento de cdigo correspondiente al valor 20 de la variable Valor.
break; //Ruptura del caso 20.
case 50: //Fragmento de cdigo correspondiente al valor 50 de la variable Valor.
break; //Ruptura del caso 50.
default: //Cdigo correspondiente para cualquier otro valor por defecto.
break; //Ruptura del default.
}
2.6.4 El ciclo iterativo while y do while
El ciclo iterativo while repite o ejecuta un fragmento de programa siempre y cuando la condicin
contenida en el while sea verdadera. Para conocer la forma de declarar este tipo de ciclo observe
el siguiente ejemplo:

short CONT=0; //Declaracin de variable entera que cuenta hasta 100.
while( CONT<100 ) //Declaracin del ciclo while.
{
CONT++; //Incremento de la variable CONT.
}

La implementacin de un ciclo do while, es similar al ciclo while, con la diferencia puntual de
que en este ciclo el fragmento de cdigo se ejecuta y despus evala la condicin del while. En
conclusin el cdigo se ejecuta por lo menos una vez antes de evaluar la condicin. En el
siguiente ejemplo se puede ver la forma de usar este tipo de ciclo:

short CONT=0; //Declaracin de variable entera que cuenta hasta 100.
do //Declaracin del ciclo do while.
{
33
CONT++; //Incremento de la variable CONT.
} while( CONT<100 );
2.6.5 El ciclo iterativo for
El ciclo iterativo for es una estructura parecida al ciclo while, la diferencia es una estructura ms
compleja en los parntesis de la condicin. La condicin cuenta con tres parmetros, el primero
es un espacio de cdigo para dar valores iniciales a una o ms variables, el segundo campo
permite crear una condicin lgica que hace repetir el fragmento de cdigo del for cuando est es
verdadera, el ltimo espacio realiza cambio sobre una o ms variables, tal como: incrementos,
decrementos, etc. Las variables que se cambian en el ltimo campo son generalmente las mismas
que se inician en el primer campo, pero est no es una regla. Observe la estructura del for en el
siguiente modelo:

for( _INICIO_ ; _CONDICION_; _CAMBIO_ )
{
}

Para conocer el funcionamiento del ciclo for observe el siguiente ejemplo:

short A; //Declaracin de variables.
short B;
for( A=0, B=100; (A<100)||(B>20); A++, B-- ) //Estructura del ciclo for.
{
//Fragmento de cdigo que se ejecuta cuando la condicin del for es verdadera.
}
2.6.6 Uso anidado de ciclos iterativos
Muchas de las aplicaciones incrementan su funcionalidad y optimizan el tamao del cdigo de
mquina final al usar los ciclos iterativos de forma anidada. La anidacin de ciclos consiste en
ejecutar un ciclo dentro de otro. Un ciclo puede contener uno o ms ciclos anidados. Para
comprender este concepto de mejor manera observe el siguiente ejemplo:

short COL; //Declaracin de variables.
short FIL;
short MATRIZ[10][10]; //Declamacin de un vector bidimensional.
for( COL=0; COL<10; COL++ ) //Declaracin de ciclo for.
{
//Fragmento del primer ciclo.
for( FIL=0; FIL<10; FIL++ ) //Declaracin de ciclo for anidado.
{
//Fragmento del ciclo anidado.
MATRIZ[COL][FIL] = COL*FIL;
}
}
El ejemplo anterior, guarda valores en una matriz de 10 por 10, recorriendo una a una las
posiciones de la misma.
34
3 El simulador ISIS de Proteus
El simulador ISIS de Proteus es un poderoso paquete de software, desarrollado por la compaa
labcenter electronics, que se ha posicionado desde hace mas de 10 aos, como una de las
herramientas ms tiles para la simulacin de los microcontroladores PICMicro. El ISIS permite
la simulacin de las familias de los PICMicro ms populares tales como la: 12F, 16F, 18F.
Adems de los PIC, el ISIS puede simular una gran variedad de dispositivos digitales y
analgicos, entre los dispositivos digitales es posible simular displays de siete segmentos, de
caracteres, y grficos. ISIS puede simular sensores de temperatura, humedad, presin, y
luminosidad, entre otros. El simulador permite, simular actuadores como: motores dc, servo
motores, luces incandescentes entre otros. Es posible simular perifricos de entrada y salida
como teclados, y puertos fsicos del ordenador como: RS232, y USB. Este simulador cuenta con
una amplia variedad de instrumentos de medicin como voltmetros, ampermetros,
osciloscopios, y analizadores de seal. En conclusin ests y otras caractersticas hacen del ISIS
de Proteus, una herramienta ideal para el diseo y estudio de los PICMicro. Una versin
demostrativa del paquete de software se puede descargar de la pgina: www.labcenter.com. En la
siguiente imagen se puede apreciar la apariencia visual del entorno de desarrollo del ISIS:



Figura 3-1

El uso y trabajo bajo en el torno de ISIS demanda una amplia cantidad de herramientas y
opciones que se deben conocer pero se conocern paulatinamente en el transcurso de los
ejemplos.
35
3.1 Caractersticas bsicas del ISIS para simular
En la siguiente seccin se mostrarn las caractersticas bsicas para hacer la primera simulacin
en ISIS. Como primera medida se debe identificar la paleta de dispositivos, que est a la
izquierda de la pantalla, en est paleta el desarrollador debe identificar el botn P, para mayor
claridad observe la siguiente imagen:


Figura 3-2

Al picar el botn P, el programa abre una nueva ventana que permite buscar los dispositivos
electrnicos por medio de la referencia comercial, o bajo la clasificacin que el mismo ISIS tiene.
Para buscar un dispositivo por medio de la referencia se digita la referencia en la casilla:
Keywords, el programa genera una lista en la parte derecha de la ventana con los dispositivos
relacionados a la solicitud del usuario. Para seleccionar un dispositivo de est lista se da doble
clic sobre cada uno de los numerales de la lista. Para iniciar busque los siguiente dispositivos:
BUTTON, LED-RED, RES, que corresponden a un pulsador, un LED de color rojo, y una
resistencia. Despus de este proceso, en la paleta de dispositivos debe verse lo siguiente:


Figura 3-3

El paso siguiente es buscar las terminales de referencia y poder, para este fin se debe pulsar el
icono siguiente: este se encuentra en la paleta de herramientas que est en la parte izquierda
de la ventana del programa. Cuando este botn se pica permite ver una lista de terminales, en las
36
cuales se encuentra GROUND, y POWER, las cuales corresponden respectivamente a la
referencia elctrica y al poder o Vcc. La terminal de poder tiene una diferencia de potencial por
defecto de 5 voltios. Para colocar ests terminales en el rea de trabajo se pica los tems en la
paleta de terminales y posteriormente en el rea de trabajo, despus de est accin en el rea de
trabajo se debe ver lo siguiente:

Figura 3-4

El paso siguiente es pegar los dispositivos en el rea de trabajo para esto pique el botn: que
se encuentra en la paleta de herramientas de la izquierda. Para pegar los dispositivos en el rea de
trabajo se sigue el mismo procedimiento de las terminales, al finalizar se bebe tener la siguiente
vista:

Figura 3-5

El paso siguiente es realizar las conexiones elctricas, para este ejemplo se conectan todos los
elementos en serie, para este fin el cursor del ratn adopta la forma de lpiz, para hacer la
conexin entre dos terminales se pica una terminal y despus la siguiente. El programa termina
rutiando la conexin. Al terminar las conexiones se ve la siguiente vista:

37


Figura 3-6

Para finalizar se puede cambiar el valor de la resistencia dando clic izquierdo sobre la resistencia,
con est accin sale una ventana que permite editar el valor de la resistencia, que por defecto es
de 10k, lo que se debe hacer es cambiarlo por 330.

El paso siguiente es ejecutar o correr la simulacin para esto se utiliza la paleta de reproduccin
que est en la parte inferior izquierda de la pantalla. La apariencia de est paleta es la siguiente:


Figura 3-7

Por ltimo se pica el botn de play y la simulacin se ejecuta, cuando la simulacin este
corriendo se puede pulsar el BUTTON, y ver el efecto de la simulacin. Este simple ejemplo
permite mecanizar el proceso de creacin de un circuito digital, para su posterior simulacin.

La creacin de circuitos en ISIS, implica hacer otra serie de acciones, que sern tratadas en el
transcurso de los ejemplos.
38
4 Creacin del primer
programa en MikroC PRO
El proceso siguiente debe ser mecanizado para ser implementado cada vez que se haga un
proyecto o programa nuevo para un PICMicro. Al correr el MikroC PRO, se identifica en el
men superior el tem Project, se pica y dentro de este se pica New Project, con est accin el
programa despliega un asistente fcil de usar para crear el nuevo proyecto. La apariencia visual
de este asistente es la siguiente:


Figura 4-1

La siguiente accin es pulsar el botn Next, con este paso el asistente muestra una casilla para
seleccionar la referencia del PICMicro, que se desea usar. En est opcin seleccione el PIC
P16F84A. El siguiente paso es definir la frecuencia se oscilacin con la cual trabajar el PIC, en
este ejemplo se selecciona 4.000000 MHz. La siguiente opcin permite definir el directorio en
donde el desarrollador guardar el proyecto, en este directorio el programa guardar todos los
archivos requeridos, en los cuales la fuente del cdigo ser el archivo con extensin .c, y el
ejecutable del PIC es el archivo .hex. El siguiente paso solicita adicionar archivos que sern
anexados al proyecto. Cuando se realiza un proyecto nuevo este paso se puede omitir y se pulsa
Next, El ltimo tem del asistente pregunta si el desarrollador quiere seleccionar las libreras que
usar en este trabajo, por defecto este tem selecciona todas las libreras habilitadas para este PIC,
39
lo mejor es dejar todas las libreras activas. Por ltimo se termina la configuracin y se crea el
proyecto, al terminar debe aparecer una vista como la siguiente:


Figura 4-2

Cuando un cambio se realice sobre el cdigo del programa se debe compilar el cdigo picando el
siguiente botn: que est ubicado en la parte superior del programa dentro de la paleta de
herramientas. Est accin genera los resultados de la compilacin que se encuentran en la parte
inferior de la ventana del programa. Los mensajes se deben terminar con un texto de finalizacin
exitosa.

Para iniciar la edicin del proyecto, se configuran los puertos del PIC, y posteriormente se
encierra el programa en un bucle infinito. El PIC 16F84A, tiene dos puertos l A y el B, para
configurar los puertos como salida o como entrada se manipula el registro TRIS. Cada puerto
cuenta con su respectivo registro TRIS, que hace alusin a los tres estdos posibles, alto, bajo, y
alta impedancia. Los registros TRIS cuentan con el mismo nmero de bits del puerto, por ejemplo
el puerto B o PORTB de este PIC tiene 8 bits, por lo tanto el TRISB tambin tiene 8 bits. Los bits
de los registros TRIS, son correspondientes al puerto, y definen bit a bit el estdo del puerto. Si
un bit en el TRIS es 0 el mismo bit en el puerto es de salida, y si el bit del TRIS es 1 el mismo bit
del puerto es de entrada o est en alta impedancia. Para entender este concepto con mayor
claridad observe y analice el siguiente ejemplo:

TRISB = 0b11110000; // Configura los cuatro bits de menor peso como salida, y
//los cuatro bits de mayor peso como entrada.
PORTB=0b00000000; //Los bits de salida asumen un 0 lgico.

Este ejemplo usa un pulsador y un par de LEDs para ver el comportamiento del programa.
Observe y analice el programa a continuacin:
void main ( void )
40
{
unsigned int CONTADOR=0;
TRISB = 0b11110000; // Configura los cuatro bits de menor peso como salida, y
//los cuatro bits de mayor peso como entrada.
PORTB=0b00000000; //Los bits de salida asumen un 0 lgico.
while( 1 ) //Bucle infinito
{
if( PORTB.F7==0 ) //Evala si bit RB7 es 0
{
if( PORTB.F0==1 ) //Evala el valor del bit RB0 y conmuta su valor.
PORTB.F0=0;
else
PORTB.F0=1;
while( PORTB.F7==0 ); //Espera a que el RB7 cambie a 1.
}
CONTADOR++; //Incrementa el valor del CONTADOR.
//La siguiente condicin if cambia automticamente el estdo del bit RB1
if( CONTADOR&0x0100 ) //Evala si el bit 8 del CONTADOR es 1
PORTB.F1=1;
else
PORTB.F1=0;
}
}

El paso siguiente es hacer la simulacin en ISIS, las resistencias de los LEDs deben ser
cambiadas a 330, la terminal Master Clear, MCLR debe ser conecta a Vcc para que el PIC, no
se reinicie al terminar se debe ver de la siguiente forma:


Figura 4-3
41
Antes de correr la simulacin se debe cargar el archivo .hex, para este proceso se hace clic
izquierdo sobre el PIC, y aparece una ventana que permite buscar el archivo .hex, en est ventana
tambin se ajusta la frecuencia de oscilacin. Por defecto este valor es 1MHz, para efectos de
simulacin en este caso se debe seleccionar 4MHz, la vista de est ventana es la siguiente:


Figura 4-4


Para fines de la programacin fsica del microcontrolador es importante tener presente las
condiciones de configuracin del PIC, cada uno de los microcontroladores de Microchip, poseen
un campo de memoria que caracteriza el comportamiento de real del PIC, entre estos se pueden
destcar; el tipo de oscilador o reloj de procesamiento, por ejemplo cuando se usa un cristal de
4M Hz, el oscilador del PIC se debe configurar como XT, si el oscilador es de 20M Hz se usa la
configuracin HS, si se trata de un cristal de baja velocidad como 400K Hz se usa la
configuracin LP, y si se implementa un oscilador por medio de circuito RC, o circuito de
resistencia en serie con capacitor se usa la opcin RC. De la misma forma es posible configurar
otras opciones como el uso del perro guardin, la proteccin de cdigo en memoria FLASH y
EEPROM, est ltima opcin es de suma importancia para proteger la informacin del
microcontrolador y evitar que el programa o los datos de la memoria sean ledos. Para modificar
la configuracin del PIC, se debe buscar el tem Edit Proyect que se encuentra en la pesta
Proyect, del men principal del programa MikroC PRO.

El acceso a este tem se puede apreciar en la siguiente figura:

42

Figura 4-5


Despus de picar est opcin el compilador MikroC PRO, despliega una ventana con casillas de
seleccin para editar las opciones de configuracin del PIC, en funcin del microcontrolador est
ventana puede cambiar de apariencia dado que no todos los PIC, cuentan con las mismas
configuraciones, sin embargo en la siguiente figura se puede apreciar la apariencia de esta
ventana para un PIC 16F877A:

43


Figura 4-6

44
5 Visualizacin de datos
El diseo de sistemas microcontrolados implican en algunos casos la visualizacin de datos al
usuario, para este fin se pueden usar display 7 segmentos, display LCD de caracteres y display
grficos LCD. En este captulo se estudia y se ejemplarizan estos dispositivos.
5.1 Display de 7 segmentos
Un display 7 segmentos es un dispositivo que permite visualizar un nmero limitado de
caracteres esencialmente numricos, sin embargo es posible visualizar unos pocos caracteres mas
como: b, d, E, A, o, F, C, -. Los display 7 segmentos son un arreglo de diodos LED, organizados
de tal forma que permiten visualizar los caracteres segn los segmentos que estn activos. Los
displays de 7 segmentos tienen una designacin estndar de cada segmento que es consecutiva de
la a hasta la g. Est designacin y la apariencia fsica de estos displays se pueden apreciar en
las siguientes figuras:



Figura 5-1

Los display de 7 segmentos son fabricados en dos formatos; de nodo comn y de ctodo comn,
los display de 7 segmentos tambin existen en un formato dinmico, estos ltimos usan dos o ms
dgitos en un solo encapsulado conectando todos los segmentos en paralelo pero con los
terminales comunes por separado. Las siguientes figuras muestran displays de 7 segmentos en su
formato dinmico:


Figura 5-2
45
La terminal DP, que se puede apreciar en la figura anterior es un octavo segmento que en algunos
displays es implementado y corresponde al punto decimal, este se usa si la aplicacin as lo
requiere.
5.1.1 Control de display de 7 segmentos
Para realizar el primer ejemplo con este display se bebe conocer como realizar la asignacin de
pines del PIC, a cada uno de los segmentos del display se debe conectar un pin del PIC, para
hacer un diseo optimo se puede asignar los pines en orden consecutivo de un puerto por ejemplo
el segmento a se conecta al pin RB0, el segmento b al pin RB1, y as sucesivamente hasta el
segmento g al pin RB6. Sin embargo la designacin de pines la puede hacer el desarrollador de
manera arbitraria. Es importante conocer una herramienta con la que cuenta el paquete de
software MikroC PRO, que permite editar los dgitos del display, para este fin se pica el tem
Tools en el men del MikroC PRO, dentro de este nuevo men se pica el tem Seven Segment
Editor. Con est accin emerge una nueva ventana que permite editar de manera simple los
segmentos del display de 7 segmentos. A medida que se edita el display aparece el valor
constante que debe ser usado en las salidas del puerto que se designe para su control. El editor
permite implementar las constantes para un display de nodo o de ctodo comn, de la misma
forma es posible usar las constantes en formato decimal o hexadecimal. La apariencia visual del
editor es la siguiente:


Figura 5-3

El uso de est herramienta, implica que todos los pines del display estn asignados a un mismo
puerto, y en orden consecutivo como se coment anteriormente. Para la visualizacin de los
dgitos en el display se debe organizar la informacin de los dgitos en orden consecutivo, en el
caso de este ejemplo del 0 al 9. Para este fin la forma de mayor simplicidad es con el uso de una
cadena de datos que contenga los 10 cdigos de los dgitos. En el siguiente ejemplo se declarar
un arreglo constante con los cdigos de cada dgito, para este ejemplo se usar un display de
46
ctodo comn. Observe la forma de declarar las constantes que deben ser insertadas antes de la
funcin main:

const unsigned short DIGITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};

Para visualizar los dgitos en el display de 7 segmentos, este ejemplo usar el puerto B del
microcontrolador PIC 16F84A, la visualizacin de los dgitos estr controlada por una rutina
que cambia temporizadamente por medio de la funcin delay_ms que est predefinida por las
libreras del compilador. Est funcin tiene como parmetro de entrada un nmero entero que
representa el tiempo en milisegundos, durante los cuales el PIC ejecutar un retardo, de la misma
forma se puede usar la funcin delay_us, que es idntica a delay_ms pero en micro segundos.

A continuacin se muestra el cdigo fuente del PIC, para este ejemplo:

const unsigned short DIGITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};

void main ( void )
{
unsigned short CONTADOR=0;
TRISB = 0; // Configura el puerto B como salida
while( 1 ) //Bucle infinito
{
PORTB = DIGITOS[CONTADOR]; //Se visualiza el digito correspondiente al
//nmero guardado en la variable CONTADOR.
CONTADOR++; //Se incrementa el valor del conteo.
47
delay_ms(1000); //Se hace un retardo de 1 segundo.
}
}

El paso siguiente es realizar la simulacin en ISIS, para este fin se buscan los siguientes
dispositivos: 16F84A, RES, y 7SEG-COM-CATHODE, para la conexin entre el PIC, y el
display se deben usar resistencias de 330. Posteriormente se arma el siguiente circuito:


Circuito 5-1

Al correr la simulacin se debe ver un conteo en el display del 0 al 9, con una cadencia de un
segundo entre dgito y dgito.
5.1.2 Control de displays 7 segmentos dinmicos
La implementacin de displays dinmicos usa la misma teora de un solo display, la visualizacin
dinmica consiste en mostrar un solo dgito al mismo tiempo. Por ejemplo si se muestran cuatro
dgitos se activa el display de las unidades, despus se apagan y se activa el dgito de las decenas,
posterior mente se apaga y se activa el dgito de las centenas, y por ltimo se hace lo mismo con
las unidades de mil. Este proceso se debe hacer con una velocidad de tal manera que engae al
ojo humano y as se ver como si todos los dgitos estuvieran activos. Este arreglo minimiza las
conexiones elctricas y el consumo de energa, dado que en realidad solo un dgito est activo
para todo tiempo. A la vista del ojo humano los cambios deben ser de 25Hz o ms, por lo tanto
todos los dgitos deben verse durante un periodo igual al inverso de 25Hz, en este caso es 40m
segundos. Para este ejemplo se usarn 4 displays por lo tanto el tiempo visible de cada dgito
debe ser la cuarta parte del periodo es decir 10m segundos. La forma ms eficiente de mostrar los
nmeros en el display es por medio de una funcin. Con 4 dgitos es posible visualizar un nmero
de 0 a 9999, por esto el nmero puede ser consignado en una variable de tipo entera. Para ver
cada dgito por separado se hace necesario calcular cada uno de los dgitos, por ejemplo para
deducir las unidades de mil vasta con dividir el nmero en mil, y luego restr las unidades de mil
del nmero completo, este proceso se repite hasta llegar a las unidades. La activacin de los
displays se debe hacer por medio de otro puerto para este ejemplo se har por el puerto A.
Para comprender este proceso observe y analice la siguiente funcin:

48
// Declaracin de las constantes para el display.
const unsigned short DIGITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};

//Funcin para visualizar el display dinmico.
void VerDisplay( int Numero )
{
unsigned short U; //Variable para guardar las unidades.
unsigned short D; //Variable para guardar las decenas.
unsigned short C; //Variable para guardar las centenas.
unsigned short UM; //Variable para guardar las unidades de mil.
UM = Numero/1000; //Clculo de las unidades de mil.
C = (Numero-UM*1000)/100; //Clculo de las centenas.
D = (Numero-UM*1000-C*100)/10; //Clculo de las decenas.
U = (Numero-UM*1000-C*100-D*10); //Clculo de las unidades.

PORTB = DIGITOS[U]; //Visualiza las unidades.
PORTA.F0=1; //Activa en alto el primer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.

PORTB = DIGITOS[D]; //Visualiza las decenas.
PORTA.F1=1; //Activa en alto el segundo display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.

PORTB = DIGITOS[C]; //Visualiza las centenas.
PORTA.F2=1; //Activa en alto el tercer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.

PORTB = DIGITOS[UM]; //Visualiza las unidades de mil.
PORTA.F3=1; //Activa en alto el cuarto display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
}

Por ltimo se completa el cdigo fuente con la funcin main de la siguiente forma:
49

void main ( void )
{
unsigned short N=0; //Variable de conteo.
int Numero=0;
TRISB = 0; //Configura el puerto B como salida
TRISA = 0; //Configura el puerto A como salida
PORTA = 0; //Se desactiva todos los displays
while( 1 ) //Bucle infinito
{
//Se visualiza el valor de Nmero.
VerDisplay( Numero ); //Est funcin dura aproximadamente 40m segundos.
//Se cuentan 12 incrementos en N para hacer un incremento
//en Nmero aproximadamente cada 500m segundos.
N++;
if( N==12 )
{
N=0; //Se reinicia el conteo de N.
Numero++; //Se incrementa el valor de Nmero.
if( Numero==10000 ) //Se evala si Nmero vale 10000
Numero=0; //y se reinicia en 0 si es 10000.
}
}
}

Al terminar y compilar el programa se realiza la simulacin en ISIS, con los siguiente
dispositivos: 16F84A, RES, 7SEG-MPX4-CC, 7404. Finalmente se construye el siguiente
circuito:


Circuito 5-2
50
Para fines prcticos los inversores 7404 se pueden remplazar por un arreglo de transistores como
se ven en la siguiente imagen:

Circuito 5-3

Cuando la simulacin este en marcha el circuito debe mostrar un conteo de 0 a 9999 con una
cadencia de 500m segundos entre cada incremento.
5.2 Display LCD de caracteres
Los display de caracteres LCD, son mdulos prefabricados que contienen controladores
incluidos. Estos displays cuentan con un bus de datos y un bus de control, para el manejo de estos
dispositivos el compilador MikroC PRO, tiene una librera predefinida para el control de estos
LCD. La apariencia fsica y la vista en ISIS de estos LCD es la que se puede apreciar en las
siguientes grficas:


Figura 5-4

Los displays LCD, permiten graficar los caracteres contemplados en el cdigo ASCII. Adems
del cdigo ASCII, los displays LCD admiten graficar hasta 8 caracteres diseados por el
desarrollador, otra caracterstica fundamental de los LCD, es la conexin del bus de datos,
fsicamente tienen 8 bits, pero es posible configurar las conexiones con solo 4 bits. La conexin
de 8 bits implica una mayor cantidad de cables para su uso, pero la velocidad de trabajo es
mayor, por consiguiente la conexin de 4 bits minimiza las conexiones pero disminuye la
velocidad de trabajo. La librera predefinida en MikroC PRO, funciona con la configuracin de 4
bits.
51

Para ver la librera predefinida para este dispositivo y otros que tiene MikroC PRO, se debe picar
la paleta de herramientas ubicada en la parte derecha del programa, est paleta se identifica con
una pesta que tiene el titulo: Library Manager. Al picar est pesta se despliega un men que
muestra las diferentes libreras habilitadas para el microcontrolador que se est trabajando. En
este nuevo men se identifica el tem Lcd, posteriormente se puede picar cualquiera de las
funciones que contiene la librera para ver la ayuda correspondiente. La apariencia visual de est
paleta se puede apreciar en la siguiente imagen:


Figura 5-5

La implementacin del display LCD, requiere del uso de instrucciones y comandos secunciales
para la configuracin y desempeo del display, sin embargo la librera de MikroC PRO,
minimiza este trabajo dado que est se encarga de hacer todas ests configuraciones, haciendo
mucho ms simple el trabajo del desarrollador. Como primer paso para el uso del LCD, se
requiere definir los pines de conexin y la ejecucin de la funcin predefinida de inicio del LCD;
Lcd_Init(). La definicin de los pines de conexin la asume el desarrollador de forma arbitraria
segn su criterio. Para cumplir este objetivo se usa la siguiente declaracin de constantes:

52
//Pines de salida para el LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Bits de configuracin TRIS
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

Para cambiar los pines solo se requiere cambiar el nombre de las declaraciones del ejemplo
anterior. Como se puede ver en la declaracin inicial solo se necesitan 6 pines para gobernar el
LCD, con 4 bits de datos y 2 bits de control, el display cuenta con un tercer pin de control
denotado como WR, este pin permite leer si el display est ocupado realizando alguna operacin
o permite escribir comandos y caracteres. Para fines de la librera este pin no es requerido, y
simplemente se conecta a referencia. Por ltimo se debe invocar la funcin de inicio del display
dentro de la funcin main despus de la configuracin de puertos. Los pines de la LCD, no se
deben configurar, est tarea ya la realiza la funcin: Lcd_Init(). La declaracin de la funcin main
debe quedar de la siguiente forma:

void main( void )
{
Lcd_Init(); //Inicio del LCD.
while(1) //Bucle infinito.
{
}
}

Terminada la edicin del cdigo anterior el LCD, se inicializa y debe quedar listo para empezar a
graficar caracteres, posicionndose en la primera fila y primera columna, mostrando el cursor
parpadeante.

Los displays de caracteres se fabrican en diversas formas y colores se pueden conseguir con
pantallas de color verde, azul, y amarillo. Se fabrican con distribuciones de caracteres de forma
matricial como 2 filas, 16 columnas estos se conocen como 2x16, y de la misma forma se pueden
encontrar de 1x16, 2x16, 2x8, 2x20, 4x20, entre otros. Para los ejemplos empleados en este
captulo se usar el display de 4x20. Para iniciar la simulacin del display LCD, se debe buscar el
dispositivo LM044L, y el PIC 16F84A en el simulador ISIS. La referencia LM044L en ISIS
corresponde a un LCD de 4x20. Finalmente se realizan las conexiones como se muestra en el
siguiente circuito:
53

Circuito 5-4

El display LCD cuenta con un pin denominado vee, este pin funciona como controlador de
contraste de la pantalla, pero para fines de la simulacin no tiene efecto, este pin puede ser
conectado a referencia para generar el mayor contraste, algunas pantallas de gran tamao
requieren de un voltaje negativo externo para el control de este contraste, en sntesis, cuanto ms
negativo sea el voltaje en Vee ms oscuro ser el contraste en la pantalla. Para fines prcticos el
contraste se puede ajustar por medio de un potencimetro como se ve en la siguiente circuito:


Circuito 5-5

El paso siguiente es imprimir en la pantalla informacin, para este objetivo se pueden usar cuatro
funciones. Dos de estas funciones permiten imprimir caracteres, y las otras dos imprimen cadenas
54
de texto. Para imprimir los caracteres se puede hacer de dos maneras, la primera simplemente
imprime los caracteres en el orden consecutivo que asume el display, y la siguiente funcin
imprime los caracteres en la fila y columna que se designe por el desarrollador.
5.2.1 Funciones para imprimir caracteres
La primera funcin de impresin de caracteres es: Lcd_Chr_Cp(char out_char); cuando est
funcin es invocada imprime en la pantalla el carcter correspondiente al cdigo ASCII, que est
en el parmetro de entrada out_char. Con la impresin de un nuevo carcter la pantalla LCD,
incrementa automticamente el cursor en una posicin. Para contextualizar el funcionamiento de
esta funcin observe y analice el siguiente ejemplo:

void main( void )
{
Lcd_Init(); //Inicio del LCD.
Lcd_Chr_Cp(H); //Ests funciones imprimen letra a letra la palabra Hola.
Lcd_Chr_Cp(o);
Lcd_Chr_Cp(l);
Lcd_Chr_Cp(a);
while(1) //Bucle infinito.
{
}
}

Despus de correr la simulacin se debe observar lo siguiente en la pantalla del LCD:


Figura 5-6

Para realizar la impresin de caracteres por medio de una coordenada fila, columna, se
implementa la funcin: Lcd_Chr(char row, char column, char out_char); est funcin imprime
el carcter out_char, en la columna column y en la fila row. En el siguiente ejemplo se puede ver
cmo usar est funcin:

55
void main( void )
{
Lcd_Init(); //Inicio del LCD.
Lcd_Chr_Cp(H); //Ests funciones imprimen letra a letra la palabra Hola.
Lcd_Chr_Cp(o);
Lcd_Chr_Cp(l);
Lcd_Chr_Cp(a);
Lcd_Chr( 1, 6, 1); //Imprime el carcter 1, en la fila 1, columna 6
Lcd_Chr( 2, 7, 2); //Imprime el carcter 2, en la fila 2, columna 7
Lcd_Chr( 3, 8, 3); //Imprime el carcter 3, en la fila 3, columna 8
Lcd_Chr( 4, 9, 4); //Imprime el carcter 4, en la fila 4, columna 9
while(1) //Bucle infinito.
{
}
}

Despus de ejecutar la simulacin se debe tener la siguiente vista en la pantalla del LCD:


Figura 5-7
5.2.2 Funciones para imprimir cadenas de texto
El uso de cadenas de texto es similar a las dos funciones anteriores, para esto se pueden imprimir
cadenas de texto en el punto donde est el flujo de la impresin del LCD, o en un punto arbitrario
por medio de las coordenadas de filas y columnas. Para hacer la impresin de una cadena de texto
en el punto de impresin se utiliza la siguiente funcin: Lcd_Out_Cp(char *text); est cuenta con
un nico parmetro de entrada que es un apuntador a la cadena de caracteres en este caso la
funcin la denota como text. Para el uso de est funcin observe y analice el siguiente ejemplo:

void main( void )
{
Lcd_Init(); //Inicio del LCD.
Lcd_Out_Cp(Hola Mundo);
while(1) //Bucle infinito.
56
{
}
}

La implementacin de est funcin puede hacerse con cadenas de caracteres constantes o
variables, las cadenas constantes se denotan por medio de las dobles comillas al inicio y al final
del texto por ejemplo: Hola Mundo, el formato variable se declara con la forma: char
Text[20]=Hola Mundo;. Despus de correr la simulacin se bebe ver una vista como la que
aparece en la siguiente figura:


Figura 5-8


Para imprimir una cadena de caracteres con una coordenada como punto de inicio se implementa
la funcin: Lcd_Out(char row, char column, char *text);. Est funcin trabaja de forma similar a
la anterior, con la diferencia que se incluyen los datos de row, y column, que hacen referencia a
las filas y las columnas respectivamente. Para comprender de forma clara el funcionamiento de
esta funcin observe y analice el siguiente ejemplo:

void main( void )
{
Lcd_Init(); //Inicio del LCD.
Lcd_Out( 1, 1, Fila 1, Columna 1 );
Lcd_Out( 2, 2, Fila 2, Columna 2 );
while(1) //Bucle infinito.
{
}
}

Despus de compilar y simular este ejemplo se debe observar una vista en la pantalla del LCD
como la que se puede apreciar en la siguiente figura:

57

Figura 5-9
5.2.3 Impresin de valores numricos
La impresin de valores numricos es de vital importancia en muchos de los desarrollos. Por
ejemplo cuando se desea visualizar, el estdo de una variable, un sensor como: temperatura,
humedad, presin, o cualquier otro que se est manipulando. Para lograr este objetivo se puede
recurrir a funciones de conversin predefinidas por el compilador. Para esto se puede utilizar la
librera: Conversions, est librera cuenta con funciones que hacen la conversin de un valor
numrico a una cadena de caracteres. Si se requiere visualizar un valor entero se usa la funcin:
IntToStr(int input, char *output);, est funcin tiene dos parmetros de entrada que son: input,
que es un valor entero a visualizar, y output, que es el apuntador a una cadena de caracteres
donde se quiere escribir el forma de texto el valor que contiene el valor intput. Para entender este
tipo de conversin observe y analice el siguiente ejemplo:


void main( void )
{
int ENTERO=123; //Declaracin de una variable entera con valor inicial 123.
char Text[20]; //Cadena de caracteres para impresin de datos.
Lcd_Init(); //Inicio del LCD.
IntToStr( ENTERO,Text ); //Funcin que hace la conversin.
Lcd_Out_Cp(Text); //Impresin del texto en la pantalla LCD.
while(1) //Bucle infinito.
{
}
}


La impresin de los nmeros enteros en la cadena de texto con est funcin siempre asume un
campo fijo de 7 caracteres, es decir que si el nmero tiene menos de 7 dgitos el resto del texto se
completa con espacios vacos. Despus de compilar y simular el programa se tendr una vista en
ISIS, como la que se puede ver en la siguiente figura:

58

Figura 5-10


La impresin de nmeros con punto decimal se puede hacer con la funcin: FloatToStr(float
fnum, char *str);. La filosofa de funcionamiento de esta funcin es idntica a la anterior que
hace las conversiones de nmeros enteros. Para realizar el siguiente ejemplo se debe cambiar la
referencia del microcontrolador, esto se debe a que la capacidad de memoria del PIC 16F84A, no
es suficiente para los siguientes ejercicios. A partir de este punto se usara el PIC 16F628A, que
tiene la misma distribucin de pines del 16F84A, pero cuenta con una capacidad mayor de
memoria y con mdulos integrados superiores como la USART. Para contextualizar su
funcionamiento observe el siguiente ejemplo:


void main( void )
{
int ENTERO=123; //Declaracin de una variable entera con valor inicial 123.
float DECIMAL=12.76543; //Declaracin de una variable con punto decimal
//inicializada en 12,76543.
char Text[20]; //Cadena de caracteres para impresin de datos.
Lcd_Init(); //Inicio del LCD.
IntToStr( ENTERO,Text ); //Funcin que hace la conversin entera.
Lcd_Out(1,1,Text); //Impresin del texto en la pantalla LCD.
FloatToStr( DECIMAL,Text ); //Funcin que hace la conversin decimal.
Lcd_Out(2,1,Text); //Impresin del texto en la pantalla LCD.
while(1) //Bucle infinito.
{
}
}


Terminada la simulacin se de tener una vista como la que se aprecia en la figura siguiente:

59

Circuito 5-6

El mismo proceso se puede seguir para otros tipos de variables como son: short con la funcin:
ShortToStr(short input, char *output);
Las variables long con la funcin:
LongToStr(long input, char *output);
Las variables unsigned short con la funcin:
ByteToStr(unsigned short input, char *output);
Las variables unsigned long con la funcin:
LongWordToStr(unsigned long input, char *output);
Las variables unsigned int con la funcin:
WordToStr(unsigned int input, char *output);
5.2.4 Creacin de caracteres propios
Las pantallas de caracteres LCD, cuentan con la capacidad de almacenar hasta 8 caracteres
diseados por el desarrollador. Los valores ASCII, para los caracteres diseados por el usuario
corresponde a los valores numricos del 0 al 7. Por ejemplo, si se desea imprimir el primer
carcter diseado por el usuario se hace con las funciones de impresin de caracteres:
Lcd_Chr_Cp(0); o Lcd_Chr(1,1,0);. La creacin de caracteres propios creados por el usuario se
guardan en un campo de memoria RAM, de la pantalla LCD, por est razn deben ser
reprogramados cada vez que se inicializa la pantalla LCD. Los caracteres son un conjunto de
valores binarios que forman un mapa de bits, y dan como resultado la imagen en la pantalla con
una resolucin de 5 x 7 pxeles. La edicin y programacin de estos datos resulta dispendioso y
cuidadoso con las rdenes de bajo nivel que se beben dar a la pantalla LCD. Sin embargo el
compilador MikroC PRO, cuenta dentro de sus herramientas con un editor para los caracteres
diseados por el desarrollador. En este editor de forma simple se edita el mapa de bits del
carcter y este genera la fraccin de cdigo en lenguaje C, requerida para programar el carcter
en la pantalla. En conclusin se edita el carcter y posteriormente se pega el cdigo en la fuente
60
del proyecto que se est desarrollando. Para usar este editor se busca el tem Tools dentro del
men superior del programa MikroC PRO, y dentro de este se pica el submen: LCD Custom
character, est accin despliega la ventana del editor que tiene la apariencia que se puede ver en
la siguiente figura:


Figura 5-11

En este editor el usuario pica los cuadros de la cuadricula de color verde y al terminar la edicin
del carcter, se selecciona el valor ASCII que se asignar al carcter por medio de la casilla
Char:, este valor debe ser un nmero entre 0 y 7. Terminado este proceso se pulsa el botn
GENERATE, y con est accin el editor mostrar la fraccin de cdigo para usar en el programa
que se est desarrollando. Las siguientes grficas muestran la vista del editor cuando se hace un
carcter en la direccin ASCII 0:


Figura 5-12


Como ltimo paso se debe integrar la informacin entregada por el editor y el programa del
desarrollador, para este fin observe el siguiente ejemplo:

61
//Constantes creadas por el editor, est contiene el mapa de bits del carcter.
const char character[] = {17,14,21,14,31,4,27,0};


//Pines de salida para el LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;


//Bits de configuracin TRIS
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;


//Funcin para guardar en la memoria RAN del LCD
//el carcter del editor.
void CustomChar(char pos_row, char pos_char)
{
char i;
LCD_Cmd(64); //Direccin del carcter 0.
//Bucle for para guardar el mapa de bits.
for (i = 0; i<=7; i++) LCD_Chr_Cp(character[i]);
//Para fines prcticos est funcin puede ser ignorada.
//LCD_Cmd(LCD_RETURN_HOME);
//Impression del codigo ASCII 0.
LCD_Chr(pos_row, pos_char, 0);
}


void main( void )
{
Lcd_Init(); //Inicio del LCD.
CustomChar(1, 1);//Impresin del Carcter 0.
while(1) //Bucle infinito.
{
}
}


Transcurrida la edicin compilacin y simulacin se debe tener la siguiente vista en la simulacin
de ISIS:
62

Figura 5-13

Para optimizar el uso de la generacin de caracteres arbitrarios el desarrollador puede
simplemente grabar la memoria al principio de las configuraciones y despus hacer la impresin
de los caracteres, editados del 0, al 7. Para esto se debe tener presente el arreglo constante de
datos que corresponden a los mapas de bits, la direccin inicial que muestra el editor, e invocar
las funciones de impresin de caracteres cuando sea necesario. Para formalizar est idea observe
y analice el siguiente ejemplo que imprime en la pantalla la imagen de 4 caracteres con forma de
extraterrestres:

//Declaracin de constantes, representan los mapas de bits,
//de un marcianito animado. Estos cdigo son el resultado del editor de caracteres de
//MikroC PRO.
const char Marciano1[] = {17,14,21,14,31,4,27,0}; //Direccin inicial 64.
const char Marciano2[] = {17,14,21,14,31,4,10,0}; //Direccin inicial 72.
const char Marciano3[] = {17,14,21,14,31,21,10,0}; //Direccin inicial 80.
const char Nave[] = {24,28,30,31,30,28,24,0}; //Direccin inicial 88.

//Pines de salida para el LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Bits de configuracin TRIS
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;


63
//Declamacin de funcin para guardar en RAM los caracteres.
//Est funcin es diseada por el desarrollador.
void Lcd_RAM_Car( char IntDir, const char *Mapa )
{
char i;
LCD_Cmd(IntDir); //Direccin inicial.
//Bucle para guardar el mapa en la RAM del LCD.
for( i=0; i<8; i++ ) LCD_Chr_Cp( Mapa[i] );
}

void main( void )
{
Lcd_Init(); //Inicio del LCD.
Lcd_RAM_Car( 64, Marciano1 );//Se guarda el character 1
Lcd_RAM_Car( 72, Marciano2 );//Se guarda el character 2
Lcd_RAM_Car( 80, Marciano3 );//Se guarda el character 3
Lcd_RAM_Car( 88, Nave );//Se guarda el character 4
LCD_Chr(1, 1, 0);//Se imprime el carcter Marciano 1.
LCD_Chr(1, 2, 1); //Se imprime el carcter Marciano 2.
LCD_Chr(1, 3, 2); //Se imprime el carcter Marciano 3.
LCD_Chr(1, 4, 3); //Se imprime el carcter Nave.

while(1) //Bucle infinito.
{
}
}

Terminada la compilacin y corrida la simulacin se bebe tener una vista como la siguiente en el
simulador ISIS:


Figura 5-14

La impresin de informacin en la pantalla LCD, implica en algunos casos la necesidad de
cambiar las caractersticas del cursor. Para esto, es posible sustituir el cursor por uno que no es
slido o desactivar el efecto parpadeante del mismo, incluso se puede simplemente desactivar el
cursor. Con el fin de realizar cambios de caractersticas en el LCD, se usa la funcin:
64
Lcd_Cmd(char out_char);, en la cual se ingresan los comandos de configuracin, por medio del
parmetro: out_char. Para colocar un cursor no slido, o raya al piso ( _ ), se usa el siguiente
comando: Lcd_Cmd(_LCD_UNDERLINE_ON);, para activar el cursor slido parpadeante se
implementa el comando: Lcd_Cmd(_LCD_BLINK_CURSOR_ON); Para desactivar el cursor y
hacerlo no visible se puede invocar el comando: Lcd_Cmd(_LCD_CURSOR_OFF);.
5.3 Display LCD grficos
Los display grficos, son mdulos similares a los LCD de caracteres, su particularidad principal
es que permiten graficar un mapa de bits de mayor resolucin. Estos se pueden adquirir
comercialmente en tamaos como: 128x64, 128x128, 240x320, pxeles entre otros. Estos
dispositivos de manera similar a los displays de caracteres requieren un protocolo de
configuracin, y para ello cuentan con un bus de datos y un bus de control. Los LCD grficos,
permiten imprimir fragmentos de lneas, horizontales o verticales armando en conjunto una
imagen total. Para fines de estudio y anlisis en este captulo se demostrar el control sobre un
LCD grfico de 128x64 pxeles. La apariencia fsica y la vista desde el simulador ISIS, se puede
apreciar en las siguientes imgenes:



Figura 5-15

Estos dispositivos cuentan con 20 pines de los cuales 8 son el bus de datos, 6 son de control, 2
son de polarizacin, y 2 son para ajustar el contraste. De la misma forma que el LCD de
caracteres para fines de simulacin los pines de contraste son ignorados. Sin embargo para fines
prcticos los pines de contraste se deben instalar con un potencimetro como se muestra en la
siguiente figura:

Figura 5-16
65
Para los ejemplos tratados en este captulo, se crear un proyecto nuevo en MikroC PRO, con el
microcontrolador 16F877A. Este dispositivo es un PIC de 40 pines y 8K bytes de memoria de
programa, la cual es suficiente para realizar las primeras practicas con el LCD grfico.
Nuevamente las bondades del compilador MikroC PRO, brindan una librera especializada en el
uso y control de este display grfico. Para esto se cuenta con la librera Glcd, ubicada en la paleta
de libreras. Como primera medida para configurar el mdulo grfico, se definen de manera
arbitraria los pines por los cuales se conectar el display. Para esto se hace una declaracin de
bits constantes similar a la que se hace con el LCD de caracteres. En el siguiente ejemplo se
puede apreciar est declaracin:

// Declaracin del puerto con el bus de datos.
char GLCD_DataPort at PORTD;
//Declaracin de los pines de control.
sbit GLCD_CS1 at RB0_bit;
sbit GLCD_CS2 at RB1_bit;
sbit GLCD_RS at RB2_bit;
sbit GLCD_RW at RB3_bit;
sbit GLCD_EN at RB4_bit;
sbit GLCD_RST at RB5_bit;
//Declaracin de los registros de TRIS de control.
sbit GLCD_CS1_Direction at TRISB0_bit;
sbit GLCD_CS2_Direction at TRISB1_bit;
sbit GLCD_RS_Direction at TRISB2_bit;
sbit GLCD_RW_Direction at TRISB3_bit;
sbit GLCD_EN_Direction at TRISB4_bit;
sbit GLCD_RST_Direction at TRISB5_bit;

Para inicializar el display se usa la funcin: Glcd_Init(); despus de las configuraciones del PIC
dentro de la funcin main. El paso siguiente es cargar alguna grfica, para este ejemplo se
dibujar en el display la siguiente imagen:




Figura 5-17


La configuracin antes citada se debe respetar en las conexiones fsicas con el display grfico. En
la creacin del circuito electrnico en el simulador ISIS, se implementan los dispositivos: PIC
16F877A, y el mdulo grfico: AMPIRE 128x64. Posteriormente se realizan las conexiones
respectivas como se puede apreciar en la siguiente grfica:

66

Circuito 5-7

Las imgenes que se desean cargar deben ser editadas con anterioridad en algn editor de
imgenes como el Paint de Windows. Estos archivos deben respetar las dimensiones de la
pantalla grfica en este caso de 128x64 pxeles. Por ltimo el archivo debe ser guardado en
formato bmp, y color monocromtico. Para el ingreso del mapa de bits, se puede usar un
herramienta incluida en el MikroC PRO, denominada: GLCD Bitmap Editor, este editor se
ejecuta buscando en el men principal dentro del tem Tools, y su submen GLCD Bitmap Editor.
Al correr est aplicacin se debe tener una vista como la siguiente:

Figura 5-18
67
En est aplicacin se pica la pesta: KS0108, y se asegura la seleccin circular de 128x64
(KS0108). Posteriormente se pulsa el botn Load BMP Picture, y se carga el archivo de imagen
previamente diseado en el editor de imagen. Seguidamente se selecciona el crculo con la opcin
mikroC Code, y se pulsa el botn: Create CODE. Est accin genera el cdigo en lenguaje C,
para agregar al cdigo de programa en el inicio en la parte de la declaracin de constantes. Est
declaracin es un arreglo de tipo: const unsigned char. Para el caso prctico de este ejemplo el
resultado es el siguiente:

// ------------------------------------------------------
// GLCD Picture name: Imagen.bmp
// GLCD Model: KS0108 128x64
// ------------------------------------------------------
unsigned char const Imagen_bmp[1024] = {
255, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
193,241,193, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,129,129,129,129,129, 65, 65, 65,
65, 65, 65, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 65, 65, 65, 65, 65, 65, 65,129,129,129,
129, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,255,
255, 0, 0, 0, 0, 16, 48,112,112,240,240,240,240,240,248,254,
255,255,255,254,248,240,240,240,240,240,112,112, 48, 16, 0, 0,
0, 0, 0, 0, 0, 0,128, 64, 64, 32, 32, 16, 16, 8, 8, 4,
4, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 2, 2, 2, 4, 4, 8, 8, 8, 16, 16, 32,
64, 64,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0,129,241,255,255,127,127,
63, 31, 63,127,127,255,255,241,129, 0, 0, 0, 0, 0, 0,192,
32, 16, 12, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0,192,192,192,192,192,192,192,128,128, 0, 0, 0,192,192,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,192, 64,192,128,192, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 2, 2, 12, 16, 32,192, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0,240,240,240,
240,240,240,240,240, 0, 0, 1, 3, 0, 0, 0, 0,252, 3, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0,255,255, 0, 0, 0, 0, 0,129,255,126, 0, 0,254,254,
0, 0,156,190, 54,118,102,238,204, 0, 0,248,252,182, 54, 54,
188,184, 0, 0,254,254, 12, 6, 6, 6,254,252, 0, 0,248,252,
142, 6, 6,142,252,248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,248, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,255,255,
255,255,255,255,255, 0, 0, 0, 0, 0, 0, 0, 0, 1, 14, 16,
96,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 3, 3, 3, 3, 3, 3, 3, 1, 1, 0, 0, 0, 3, 3,
68
0, 0, 1, 3, 3, 3, 3, 3, 1, 0, 0, 0, 1, 3, 3, 3,
1, 0, 0, 0, 3, 3, 0, 0, 0, 0, 3, 3, 0, 0, 0, 1,
3, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,128, 64, 48, 14, 1, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48,240,240,255,255,255,
255,255,255,255,255,240,240, 48, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 2, 4, 8, 8, 16, 32, 32, 64, 64,128,128, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128, 64, 64, 32,
32, 16, 8, 8, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 31,255,255,
255,255,255,255, 31, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
30,226, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128, 64,
64, 64, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 16, 16, 16, 16, 16, 16, 8,
8, 8, 8, 4, 4, 4, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,
255,128,128,128,128,128,128,128,128,128,128,128,128,128,128,131,
159,159,131,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,135,152,136,136,136,132,132,130,130,129,129,129,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,255
};

La declaracin anterior contiene codificada la informacin del mapa de bits cargado en el editor.
La vista final del generador debe ser la siguiente:

Figura 5-19
69
Despus de editar, inicializar, y anexar el mapa de bits en el cdigo fuente se tiene la siguiente
fuente total:

// Declaracin del puerto con el bus de datos.
char GLCD_DataPort at PORTD;

//Declaracin de los pines de control.
sbit GLCD_CS1 at RB0_bit;
sbit GLCD_CS2 at RB1_bit;
sbit GLCD_RS at RB2_bit;
sbit GLCD_RW at RB3_bit;
sbit GLCD_EN at RB4_bit;
sbit GLCD_RST at RB5_bit;

//Declaracin de los registros de TRIS de control.
sbit GLCD_CS1_Direction at TRISB0_bit;
sbit GLCD_CS2_Direction at TRISB1_bit;
sbit GLCD_RS_Direction at TRISB2_bit;
sbit GLCD_RW_Direction at TRISB3_bit;
sbit GLCD_EN_Direction at TRISB4_bit;
sbit GLCD_RST_Direction at TRISB5_bit;

unsigned char const Imagen_bmp[1024] = {
255, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
193,241,193, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,129,129,129,129,129, 65, 65, 65,
65, 65, 65, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 65, 65, 65, 65, 65, 65, 65,129,129,129,
129, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,255,
255, 0, 0, 0, 0, 16, 48,112,112,240,240,240,240,240,248,254,
255,255,255,254,248,240,240,240,240,240,112,112, 48, 16, 0, 0,
0, 0, 0, 0, 0, 0,128, 64, 64, 32, 32, 16, 16, 8, 8, 4,
4, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 2, 2, 2, 4, 4, 8, 8, 8, 16, 16, 32,
64, 64,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0,129,241,255,255,127,127,
63, 31, 63,127,127,255,255,241,129, 0, 0, 0, 0, 0, 0,192,
32, 16, 12, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0,192,192,192,192,192,192,192,128,128, 0, 0, 0,192,192,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,192, 64,192,128,192, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 2, 2, 12, 16, 32,192, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0,240,240,240,
240,240,240,240,240, 0, 0, 1, 3, 0, 0, 0, 0,252, 3, 0,
70
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0,255,255, 0, 0, 0, 0, 0,129,255,126, 0, 0,254,254,
0, 0,156,190, 54,118,102,238,204, 0, 0,248,252,182, 54, 54,
188,184, 0, 0,254,254, 12, 6, 6, 6,254,252, 0, 0,248,252,
142, 6, 6,142,252,248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,248, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,255,255,
255,255,255,255,255, 0, 0, 0, 0, 0, 0, 0, 0, 1, 14, 16,
96,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 3, 3, 3, 3, 3, 3, 3, 1, 1, 0, 0, 0, 3, 3,
0, 0, 1, 3, 3, 3, 3, 3, 1, 0, 0, 0, 1, 3, 3, 3,
1, 0, 0, 0, 3, 3, 0, 0, 0, 0, 3, 3, 0, 0, 0, 1,
3, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,128, 64, 48, 14, 1, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48,240,240,255,255,255,
255,255,255,255,255,240,240, 48, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 2, 4, 8, 8, 16, 32, 32, 64, 64,128,128, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128, 64, 64, 32,
32, 16, 8, 8, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0,255,
255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 31,255,255,
255,255,255,255, 31, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
30,226, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128, 64,
64, 64, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 16, 16, 16, 16, 16, 16, 8,
8, 8, 8, 4, 4, 4, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,
255,128,128,128,128,128,128,128,128,128,128,128,128,128,128,131,
159,159,131,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,135,152,136,136,136,132,132,130,130,129,129,129,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,255
};

void main( void )
{
Glcd_Init(); //Inicializacin del display grfico.
Glcd_Fill(0);//Borra todo el display.
Glcd_Image(Imagen_bmp); //Graficacin del mapa de bits.
while(1)//Bucle infinito.
{
}
}
71
La funcin: Glcd_Fill(0);, rellena el contenido de la pantalla con datos binarios iguales a 0, este
proceso equivale a borrar toda la pantalla del LCD. Finalizada la creacin del cdigo, y
compilado el proyecto la simulacin en ISIS debe mostrar una vista como la siguiente:


Figura 5-20

La carga de mapas de bits, solo est limitada por el tamao de las mismas, es decir que se pueden
anexar tantas imgenes como la memoria de programa del PIC, soporte. Si se requiere anexar
ms imgenes y la memoria ya no es suficiente, se debe cambiar el microcontrolador por uno que
cuente con mas campo de memoria de programa, por ejemplo el PIC 18F452, este tiene la misma
distribucin de pines del PIC 16F877A, pero cuenta con una memoria superior y puede procesar
su unidad hasta 40MHz, el PIC 16F877A se puede desempear hasta 20MHz.

Adems de cargar mapas de bits, la librera del MikroC PRO, permite dibujar lneas, crculos, y
rectngulos. Por otra parte permite cargar una o ms fuentes de texto previamente creadas para la
impresin de datos. Lamentablemente, el compilador MikroC PRO, no cuenta con un editor de
fuentes para este fin, pero es posible disearlas o incluso cargarlas de las fuentes convencionales
del sistema operativo Windows. Para lograr este cometido se requiere un editor de fuentes para
GLCD, como el software de la siguiente imagen:

Figura 5-21
72
Sin embargo la librera del MikroC PRO, contiene las siguientes fuentes de texto
predeterminadas:

- System3x5, definida como: Font_Glcd_System3x5
- FontSystem5x7_v2, definida como: Font_Glcd_System5x7
- font5x7, definida como: Font_Glcd_5x7
- Character8x7, definida como: Font_Glcd_Character8x7

Ests fuentes, en conjunto con las capacidades de graficacin y la importacin de mapas de bits
hacen de los mdulos LCD grficos, una poderosa herramienta para dar una presentacin
profesional a los proyectos requeridos por el desarrollador.

Para el siguiente ejemplo se usarn las opciones de graficacin por medio de puntos, lneas,
crculos, rectngulos, e impresin de textos.

Para hacer la impresin de puntos se implementa la funcin:
Glcd_Dot( unsigned short x_pos, unsigned short y_pos, unsigned short color );, est funcin
imprime pxeles, con el color especificado en los parmetros de la funcin. El parmetro color
puede valer: 0 para hacer un pxel de color blanco, 1 para hacer un pxel de color negro, o 2 para
invertir el color sobre el pxel dibujado.

Para dibujar lneas se utiliza la funcin:
Glcd_Line(int x_start, int y_start, int x_end, int y_end, unsigned short color);, est funcin
contempla como parmetros de entrada las coordenadas de inicio y final as como el parmetro
color este puede valer: 0 para hacer la lnea de color blanco, 1 para hacer la lnea de color negro,
o 2 para invertir el color sobre el cual se dibuja la lnea.

La impresin de rectngulos se logra con la funcin:
Glcd_Rectangle(unsigned short x_upper_left, unsigned short y_upper_left, unsigned short
x_bottom_right, unsigned short y_bottom_right, unsigned short color);, Est funcin trabaja de
forma similar a la funcin de graficacin de lneas, la diferencia radica en que las coordenadas
ingresadas son los puntos diagonales del rectngulo.

La impresin de rectngulos con relleno es posible por medio de la siguiente funcin:
Glcd_Box(unsigned short x_upper_left, unsigned short y_upper_left, unsigned short
x_bottom_right, unsigned short y_bottom_right, unsigned short color); Su funcionamiento es
equivalente a la funcin Glcd_Rectangle, con la diferencia en el parmetro del color que es
correspondiente a color de relleno.

La graficacin de crculos se realiza por medio de la funcin:
Glcd_Circle(int x_center, int y_center, int radius, unsigned short color);, est funcin respeta
las mismas condiciones del parmetro del color de las anteriores funciones, tiene las coordenadas
del centro del circulo y el radio del mismo.

Para demostrar el funcionamiento de ests funciones observe y analice el siguiente ejemplo:

void main( void )
{
73
Glcd_Init(); //Inicializacin del display grfico.
Glcd_Fill(0); //Borra el display
Glcd_Set_Font( Font_Glcd_5x7 , 5, 7, 32);// Carga fuente de texto 5x7
delay_ms(500); //Retardo de 500ms
Glcd_Dot(4,4,1); //Se dibuja un pxel en la coordenada (4,4)
delay_ms(500); //Retardo de 500ms
Glcd_Line(6,6,30,30,1); //Dibuja una lnea de (6,6) a (30,30)
delay_ms(500); //Retardo de 500ms
Glcd_Box(40,5,70,35,2);//Rectngulo relleno entre (40,5) y (70,35)
delay_ms(500); //Retardo de 500ms
Glcd_Circle(64, 32, 20, 2);// Circulo con centro en (64,32) y radio de 20
Glcd_Write_Text( "Hola mundo!", 3, 7, 1); //Impresin del texto en las coordenadas (3,7)

while(1)//Bucle infinito.
{
}
}

Lamentablemente los dispositivos LCD grficos de Proteus tienen una falla de diseo que hace
que la simulacin no funcione correctamente, este es un problema que se espera que sea
corregido en versiones futuras de ISIS. Sin embargo los resultados de la simulacin son muy
cercanos al comportamiento real del dispositivo de graficacin. El resultado en ISIS, sobre la
simulacin y una vista del comportamiento real sobre el LCD grfico, se pueden apreciar en las
siguientes figuras:


Figura 5-22
74
6 Teclados y sistemas de
entrada de datos
La interaccin de los microcontrolados requiere de sistemas de entrada para los datos con el
usuario. Para este propsito se pueden usar dispositivos como pulsadores, teclados matriciales, o
paralelos, e incluso teclados PS2 como los que usan los ordenadores de escritorio. Este captulo
se centra en el estudio de estos dispositivos.
6.1 Uso de pulsadores
La implementacin de pulsadores es una de las alternativas de mayor popularidad en las
interfaces de accin con los usuarios. Los pulsadores son de uso simple y de costo econmico en
la implementacin. Los pulsadores pueden ser normalmente abiertos o normalmente cerrados al
efecto elctrico ante el flujo de corriente. La implementacin de estos dispositivos es propensa a
los efectos de los rebotes o ruidos de tensin elctrica cuando cambian de estdo. Dado el veloz
procesamiento de los microcontroladores estos efectos de ruido, hacen que el PIC pueda detectar
cambios o estdos lgicos no definidos. Para comprender este concepto observe la siguiente
grfica que muestra el comportamiento de este ruido:


Figura 6-1

Cuando los cambios de tensin cruzan la zona indefinida, generan cambios de alto a bajo y
viceversa que el microcontrolador detecta como un pulso. Para evitar el efecto del ruido o rebotes
se debe realizar una pausa en espera de la estbilidad del estdo lgico. La duracin promedio de
un rebote es de 1 a 5 milisegundos, lo que indica que se debe hacer un retardo superior a este
tiempo para esperar la estbilidad. Un retardo adecuado para este efecto es un tiempo mayor o
igual a 10 milisegundos. Este retardo se debe aplicar despus de detectar el primer cambio sobre
el pulsador.
Para el tratamiento de los pulsadores y la eliminacin de los rebotes el compilador MikroC PRO
cuenta con la librera Button, que se puede encontrar en la paleta o pesta de libreras. Est
librera tiene la nica funcin: unsigned short Button(unsigned short *port, unsigned short pin,
unsigned short time, unsigned short active_state);, Donde port es el puerto donde se conecta el
pulsador, pin es el bit del puerto donde se conecta el pulsador, time es el tiempo en milisegundo
de espera del ruido, y active_state, es el estdo lgico para el cual se desea hacer la activacin del
pulsador. La funcin retorna 0 si el pulsador no est activo y 255 si el mismo est activo. La
instalacin de los pulsadores se puede hacer de dos formas, activo en alto o activo en bajo, en la
siguiente figura se puede apreciar la forma de configurar ests dos posibilidades:
75

Circuito 6-1
La decisin de usar la activacin en alto o en bajo, depende del desarrollador quien debe analizar
la forma de mayor simplicidad en el momento de hacer el diseo. Cabe recordar que de todos
modos la activacin final puede ser invertida con la funcin de la librera. Para analizar y estudiar
el uso de est librera se crear un nuevo proyecto con los siguientes dispositivos: PIC 16F877A,
BUTTON, RES, y LED-RED. El circuito correspondiente en ISIS, es el siguiente:

Circuito 6-2

El programa del microcontrolador respectivo es el siguiente:

void main( void )
{
//Configuracin de puertos.
TRISB=0xF0;
PORTB=0;
while(1)//Bucle infinito.
76
{
if( Button(&PORTB, 7, 100, 0) )//Evala el estdo del pulsador por RB7,
//activado en bajo.
PORTB.F0=1; //Prende el LED si el pulsador est activo.
else
PORTB.F0=0; //Apaga el pulsador si el pulsador est no activo.
}
}

Al correr est simulacin el LED debe prender cuando se pulsa el botn, y apagarse cuando se
suelta. El siguiente ejemplo conmuta el estdo del LED, para este se evala el estdo del pulsador
y se espera que se suelte el mismo:

void main( void )
{
//Configuracin de puertos.
TRISB=0xF0;
PORTB=0;
while(1)//Bucle infinito.
{
if( Button(&PORTB, 7, 100, 0) )//Evala el estdo activo del pulsador.
{
if( PORTB.F0==1 )// Se conmuta el estdo del LED.
PORTB.F0=0;
else
PORTB.F0=1;
//Se espera a que el pulsador este no activo.
while( Button(&PORTB, 7, 100, 0) );
}
}
}
6.2 Uso de Dip-Switch
Los Dip-Switch, son dispositivos mecnicos que contienen mltiples interruptores en un solo
encapsulado. Estos dispositivos permiten configurar de forma simple las caractersticas binarias
de los sistemas microcontrolados. Los Dip-Switch, se consiguen comercialmente en tamaos,
colores, y nmero de interruptores diferentes. La apariencia fsica y la vista en el simulador ISIS,
de estos dispositivos es la siguiente:


Figura 6-2
77
El uso de los Dip-Switch es similar a los pulsadores y se puede configurar de la misma forma que
un pulsador con activacin en alto o en bajo. Las configuraciones antes citadas se pueden
apreciar en el siguiente circuito:


Circuito 6-3


Para comprender y demostrar el uso de los Dip-Switch con los microcontroladores PIC, observe y
analice el siguiente ejemplo:


void main( void )
{
//Configuracin de puertos.
TRISB = 0;
PORTB = 0;
TRISC = 255;
while(1) //Bucle infinito.
{
//Se guarda el valor complementado del puerto C en el puerto B.
PORTB = ~PORTC;
}
}


Para ejecutar la simulacin en ISIS, se usan los siguientes dispositivos: 16F877A, RES, LED-
RED, DIPSW_8. Seguidamente se implementa el siguiente circuito en ISIS:

78

Circuito 6-4

Al correr la simulacin los LEDs muestran el estdo del Dip-Switch.
6.3 Uso de teclados matriciales
Las aplicaciones con microcontroladores, requieren en algunos casos el uso de teclas de entrada
de datos, para datos numricos, funciones e incluso caracteres de texto. La opcin me mayor
practicidad es el uso de teclados matriciales, estos consisten en un arreglos de pulsadores
alineados en filas y columnas, minimizando el nmero de conexiones elctricas. En las siguientes
imgenes se puede ver la apariencia fsica de un teclado matricial de 4x4 y su equivalente
esquemtico:

Figura 6-3
79
Los teclados matriciales pueden tener dimensiones mayores en funcin de la necesidad del
desarrollador. Los teclados especiales pueden ser fabricados con membranas plsticas con la
cantidad de teclas y la distribucin de las mismas, de tal manera que suplan las necesidades del
usuario. Sin embargo los teclados 4x4 permiten hacer una interfaz lo suficientemente completa
para muchas de las aplicaciones. Los teclados matriciales funcionan activando una de 4 columnas
y revisando cual de las filas se activan, este proceso determina cual es la tecla pulsada, de igual
manera el anlisis se puede hacer invirtiendo las columnas con las filas. El compilador MikroC
PRO, contiene una librera que controla y lee un teclado de 4x4, est librera cuenta con tres
funciones para este propsito. La librera que permite el uso de teclados 4x4 es: Keypad4x4, y las
funciones que usa son: Keypad_Init(void);, est inicializa el uso del teclado en funcin del
puerto designado para este fin. La funcin: char Keypad_Key_Press(void);, Est funcin, retorna
un valor de 0 a 16, don de 0 representa el teclado totalmente inactivo, los resultados del 1 al 16
representan las 16 posibles teclas. Est funcin retorna inmediatamente el estdo del teclado cada
vez que es invocada. La ltima funcin de la librera para el teclado matricial es: char
Keypad_Key_Click(void);, Su comportamiento es idntico a la funcin anterior, su diferencia
vital es que si la funcin detecta una tecla pulsada, solo retorna su valor hasta que est tecla es
soltada.
Para estudiar las caractersticas de este tipo de teclados, se mostrar un ejemplo con un nuevo
proyecto en ISIS, que requiere de los siguientes dispositivos: PIC 16F877A, RES, BUTTON,
LM016L, este ltimo es un display de caracteres de 2x16. De la misma forma se debe crear el
proyecto nuevo en el compilador MikroC PRO.
Para iniciar el proyecto se debe construir un circuito en ISIS, como el visualizado en la siguiente
figura:

Circuito 6-5
80
El programa diseado en MikroC PRO, leer el teclado y mostrar en el LCD, el valor retornado
por el mismo. Para este fin observe y analice el siguiente ejemplo:

//Declaracin del puerto para el teclado 4x4
char keypadPort at PORTC;
//Definicin pines para el LCD.
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Definicin de registros TRIS para el LCD.
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;


void main( void )
{
//Declaracin de variables.
unsigned short Tecla;
char Text[20];
//Configuracin e inicializacin del PIC.
Lcd_Init(); //Inicializacin del LCD.
Lcd_Cmd(_LCD_CURSOR_OFF); //Se apaga el cursor.
Lcd_Out(1, 1,"Tecla:"); //Se imprime texto.
while(1)//Bucle infinito.
{
Tecla=Keypad_Key_Press(); //Se lee el teclado y se guarda el resultado en Tecla.
ByteToStr(Tecla, Text); //Conversin de entero a texto.
Lcd_Out(2,1,Text); //Visualizacin del valor retornado por el teclado.
}
}


Al correr la simulacin de este programa en la pantalla se pueden ver los valores retornados por
el teclado. En la siguiente figura se puede apreciar un a vista de la simulacin cuando se pulsa la
tecla rotulada con el nmero 8:

81

Circuito 6-6

Para el caso puntual de este ejemplo el teclado hace un barrido de izquierda a derecha y de arriba
hacia abajo, empezando con la tecla 1, y terminando con la tecla D. Esto significa que los
retornos de las funciones de lectura para el teclado son los siguientes datos con respecto a cada
una de las teclas:

Retorno de las funciones Equivalencia
0 Ninguna tecla pulsada
1 Tecla 1
2 Tecla 2
3 Tecla 3
4 Tecla A
5 Tecla 4
6 Tecla 5
7 Tecla 6
8 Tecla B
9 Tecla 7
10 Tecla 8
11 Tecla 9
12 Tecla C
13 Tecla *
14 Tecla 0
15 Tecla #
16 Tecla D

Tabla 6-1
82
Hasta este punto se pueden leer del teclado una serie de nmeros pero estos no son equivalentes a
la tecla pulsada, para corregir este aspecto se debe implementar una funcin que decodifique los
valores entregados por el teclado y los convierta en el verdadero carcter que cada una de las
teclas representa. Para este fin observe la siguiente funcin que se hace por medio de una
estructura switch case para decodificar el teclado.

//Funcin para decodificar el teclado.
char LeerTeclado( void )
{
//Estructura switch case para evaluar los valores retornados
//por la librera del teclado.
switch(Keypad_Key_Press() )
{
case 1: return 1;
case 2: return 2;
case 3: return 3;
case 4: return A;
case 5: return 4;
case 6: return 5;
case 7: return 6;
case 8: return B;
case 9: return 7;
case 10: return 8;
case 11: return 9;
case 12: return C;
case 13: return *;
case 14: return 0;
case 15: return #;
case 16: return D;
default: return 0; //Tecla no pulsada.
}
}

El programa final de est aplicacin es el siguiente:

//Declaracin del puerto para el teclado 4x4
char keypadPort at PORTC;

//Definicion pines para el LCD.
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Definicion de registros TRIS para el LCD.
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
83
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

//Funcin para decodificar el teclado.
char LeerTeclado( void )
{
//Estructura switch case para evaluar los valores retornados
//por la librera del teclado.
switch( Keypad_Key_Press() )
{
case 1: return 1;
case 2: return 2;
case 3: return 3;
case 4: return A;
case 5: return 4;
case 6: return 5;
case 7: return 6;
case 8: return B;
case 9: return 7;
case 10: return 8;
case 11: return 9;
case 12: return C;
case 13: return *;
case 14: return 0;
case 15: return #;
case 16: return D;
default: return 0; //Tecla no pulsada.
}
}

void main( void )
{
//Declaracin de variables.
char Tecla;
//Configuracin e inicializacin del PIC.
Lcd_Init(); //Inicializa el LCD.
Lcd_Cmd(_LCD_CURSOR_OFF); //Se apaga el cursor.
Lcd_Out(1, 1,"Tecla:"); //Se imprime texto.
while(1)//Bucle infinito.
{
Tecla=LeerTeclado(); //Se lee el teclado y su resultado se guarda en Tecla.
Lcd_Chr(2,1,Tecla); //Visualizacin el valor retornado por el teclado.
}
}

Una vez editado, compilado y simulado este programa, se debe ver en la simulacin del display
LCD, el carcter correspondiente a la tecla que se est pulsando sobre el teclado.
84
6.4 Uso de teclados PS2 o Din
Los teclados PS2 o Din son de uso comn en los ordenadores de escritorio, e incluso existen
algunos que son flexibles, y de fcil transporte. El compilador MikroC PRO, posee una librera
especializada en el uso de estos teclados, lamentablemente estos teclados no son simuladles con
el programa ISIS. Por est razn el ejemplo que se expone en este captulo debe ser probado con
los elementos de forma real. La apariencia fsica de estos teclados es la siguiente:

Figura 6-4

La lectura de estos teclados es hace por medio de un protocolo serial que la librera ya tiene
implementada. Los teclados cuentan con un terminal PS2 o DIN, en los cuales se pueden
identificar 4 pines fundamentales, el Vcc o poder, el Gnd o referencia, un pin de datos seriales, y
un pin de reloj. La comunicacin de estos dispositivos es de forma sncrona, lo que hace
necesario la seal de reloj.
La distribucin de pines de estos terminales es la que se puede apreciar en la siguiente grfica:


Figura 6-5

En la siguiente tabla se puede apreciar la distribucin de pines de la figura anterior:

Pin PS2 Finalidad Pin DIN
1 Datos 2
3 Referencia GND 4
4 Vcc, +5V 5
5 Reloj 1

Tabla 6-2
La implementacin de este tipo de teclados se hace por medio de dos funciones contenidas en la
librera PS2, de MikroC PRO. La primera funcin es: Ps2_Config();, Est funcin debe ser
invocada en la configuracin del PIC, dentro de la funcin main, la funcin configura e inicializa
el teclado para poder ser ledo en funcin de los pines que sean definidos con anterioridad como
pin de reloj y pin de datos. La otra funcin usada es: unsigned short Ps2_Key_Read(unsigned
short *value, unsigned short *special, unsigned short *pressed);, est funcin cuenta con un
parmetro de salida que retorna 1, cuando una tecla es leda con xito, y retorna 0, cuando no se
85
detecta ninguna tecla pulsada. La funcin posee tres parmetros de entrada que permiten
identificar las siguientes caractersticas: value, este es un apuntador a una variable de tipo
unsigned short en la cual se guarda el valor de la tecla pulsada en cdigo ASCII.
El parmetro special, es un apuntador a una variable de tipo unsigned short que especifica si la
tecla que se est pulsando es de origen especial como: F1, F2, ESC, ENTER, etc. Si est variable
retorna un 1, significa que el valor codificado en value, no es un cdigo ASCII, si no un cdigo
asignado a la tecla especial que est regido por la siguiente tabla:
Tecla pulsada Retorno en value
F1 1
F2 2
F3 3
F4 4
F5 5
F6 6
F7 7
F8 8
F9 9
F10 10
F11 11
F12 12
Enter 13
Page Up 14
Page Down 15
Backspace 16
Insert 17
Delete 18
Windows 19
Ctrl 20
Shift 21
Alt 22
Print Screen 23
Pause 24
Caps Lock 25
End 26
Home 27
Scroll Lock 28
Num Lock 29
Left Arrow 30
Right Arrow 31
Up Arrow 32
Down Arrow 33
Escape 34
Tab 35

Tabla 6-3
86
Si el valor retornado es 0 el cdigo consignado en value es un carcter ASCII.
Por ltimo el parmetro: pressed, determina si la tecla denotado por los anteriores parmetros es
pulsada o soltada, si el valor retornado en pressed, es 1 la tecla fue pulsada, si retorna 0 la tecla
fue soltada.
Para el prximo ejemplo se debe tener presente el siguiente circuito electrnico de prueba:

Circuito 6-7

El cdigo de programa para este ejercicio es el siguiente, observe y analice:

//Definicin de pines para el teclado PS2.
sbit PS2_Data at RC2_bit;
sbit PS2_Clock at RC3_bit;
sbit PS2_Data_Direction at TRISC2_bit;
sbit PS2_Clock_Direction at TRISC3_bit;

//Definicin pines para el LCD.
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

87
//Definicin de registros TRIS para el LCD.
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

void main( void )
{
//Declaracin de variables.
unsigned short Tecla = 0, Especial = 0, Pulsada_soltada = 0;

//Configuracin e inicializacin del PIC.
Lcd_Init(); //Inicializa el LCD.
Lcd_Cmd(_LCD_CURSOR_OFF); //Se apaga el cursor.
Lcd_Out(1, 1,"Tecla:"); //Se imprime texto.
while(1)//Bucle infinito.
{
//Este ciclo while espera a que una tecla sea activada.
while( Ps2_Key_Read( &Tecla, &Especial, &Pulsada_soltada)==0 );

//La sentencia if evala el estdo de Pulsada y muestra en el LCD
//el resultado.
if( Pulsada_soltada==1 )
Lcd_Out(1, 7,"Pulsada");
else
Lcd_Out(1, 7,"Soltada");

//La sentencia if evala el estdo de Especial y muestra
//su resultado en el LCD.
if( Especial==1 )
Lcd_Out(2, 3,"Especial");
else
Lcd_Out(2, 3,"ASCII ");

//Visualizacin el valor retornado por el teclado.
Lcd_Chr(2,1,Tecla);
}
}

Despus de realizar la prueba de este ejemplo en display LCD, mostrar los datos enviados por el
teclado, y el estdo de las teclas especiales.
88
7 Comunicaciones seriales
Los desarrollos con microcontroladores requieren en algunos casos la implementacin de
comunicaciones seriales para establecer transporte de datos con otros dispositivos tales como:
memorias, sensores, ordenadores, e incluso otros microcontroladores. Con el fin de realizar las
comunicaciones seriales, algunos microcontroladores cuentan con mdulos seriales como: IC,
SPI, USART, y USB. Cada uno de estos formatos de comunicacin, permiten establecer
comunicaciones con mdulos diferentes. El mdulo IC, es ideal para la comunicacin con
memorias seriales como la 24LC64, 24LC128, 24LC512, entre otras. El protocolo SPI, permite
establecer comunicaciones con unidades de almacenamiento masivo como las memorias SD. El
mdulo USART es uno de los ms utilizados; este mdulo permite hacer comunicaciones con
dispositivos como sensores, mdulos de transmisin y recepcin XBee, ordenadores personales,
mdulos GPS, y otros micros. Por ltimo el mdulo USB, que est incorporado en unos pocos
micros, como el 18F2550, y el 18F4550, permite hacer la comunicacin con un ordenador
personal por medio de un puerto USB, definido como HID o dispositivo de interfaz humana.
7.1 Modulo serial IC
Algunos microcontroladores poseen este mdulo y de la misma forma el compilador MikroC
PRO cuenta con una librera especializada para el uso fcil de este protocolo. La librera se
reconoce como I2C. Est librera cuenta con siete funciones que lideran el funcionamiento del
mdulo. El protocolo IC, se caracteriza por tener una lnea de datos bidireccional y una lnea de
reloj con drenador abierto. Por este motivo en estos dos pines se debe usar una resistencia de
pull-up, generalmente de 10K. Este usa una condicin de inicio, un bloque de direccin para los
dispositivos en la red, un bloque de datos y una condicin de fin. De igual manera usa las
condiciones de repeticin de inicio y un bit de reconocimiento o acknowledge denotado como
ACK. El protocolo IC se puede usar para conectar diferentes dispositivos con direcciones
diferentes en una topologa en forma de bus. Por ltimo este protocolo debe tener una velocidad
de comunicacin que est dada en bits por segundo.

La librera de MikroC PRO, cuenta con las siguientes funciones que hacen posible el dominio del
protocolo IC:

La funcin: I2C1_Init(const unsigned long clock);, inicializa los pines de comunicacin en el
PIC, y ajusta la velocidad de comunicacin a la rata que denote el parmetro clock.
La funcin: unsigned short I2C1_Start(void);, est funcin genera la condicin de inicio y
retorna 0 si no hay ningn error en la transmisin, de otro forma retorna un valor diferente de 0.
La funcin: void I2C1_Repeated_Start(void);, est funcin genera la repeticin de inicio.
La funcin: unsigned short I2C1_Is_Idle(void);, est funcin se usa para identificar si el bus de
datos est ocupado, y retorna 1, si el bus est disponible o retorna 0, si est ocupado.
La funcin: unsigned short I2C1_Rd(unsigned short ack);, Est funcin lee un dato del bus de
datos y enva la confirmacin ack por el bus. Si ack vale 1 la confirmacin es positiva y si es 0 la
confirmacin es negativa o NO ACK.
89
La funcin: unsigned short I2C1_Wr(unsigned short data );, est funcin enva el dato data por
el bus y retorna 0 si la transmisin fue exitosa, o algo diferente de 0 si suceden errores.
La funcin: void I2C1_Stop(void);, Genera la condicin de final en el bus de comunicacin.
Para entender y estudiar el funcionamiento de este mdulo, el siguiente ejemplo se concentra en
la lectura y escritura de una memoria serial 24LC00, que tiene una capacidad de 16 direcciones.
En las siguientes grficas se puede apreciar el protocolo de comunicacin con la memoria
24LC00 para ser leda y escrita:



Protocolo de escritura


Figura 7-1


Protocolo de lectura

Figura 7-2


Para probar el ejemplo se debe implementar en ISIS, un circuito con los dispositivos: 16F877A,
BUTTON, RES, LED-RED, 24LC00, DIPSWC_8, DIPSWC_4, y el instrumento de anlisis del
protocolo I2CDEBUGGER, este ltimo se puede buscar en la paleta de herramientas ubicada en
la parte izquierda del programa MikroC PRO, en el icono de instrumentos: .



El circuito para armar es el siguiente:

90

Circuito 7-1

El cdigo de programa correspondiente para est simulacin es el siguiente:

void main( void )
{
//Declaracin de variables.
unsigned short DIRECCION;
unsigned short DATO;
//Configuracin de puertos.
ADCON1 = 6;
TRISE = 7;
TRISB = 0;
PORTB = 0;
//Inicio del mdulo I2C a 100K bps.
I2C1_Init(100000);
while(1) //Bucle infinito.
{
DIRECCION = (~PORTA)&0x0F; //Captura de la direccin.
//Protocolo de lectura de la direccin DIRECCION.
I2C1_Start();
I2C1_Wr(0b10100000);
I2C1_Wr(DIRECCION);
I2C1_Repeated_Start();
I2C1_Wr(0b10100001);
DATO=I2C1_Rd(0);
91
I2C1_Stop();
//Visualizacin del DATO en el puerto B.
PORTB = DATO;
delay_ms(100); //Retardo de 100 ms para graficar.

//Sentencia if para evaluar si se pulsa el botn de grabar.
if( Button( &PORTA, 4, 50, 0) )
{
DATO = ~PORTD; //Captura del valor del dato.
//Protocolo de grabacin.
I2C1_Start();
I2C1_Wr(0b10100000);
I2C1_Wr(DIRECCION);
I2C1_Wr(DATO);
I2C1_Stop();
//Retardo para esperar que la memoria grabe el dato.
delay_ms(50);
}
}
}


Terminada la edicin y la simulacin en ISIS, se puede apreciar los valores consignados en la
direccin que indica el DIP-SWITCH DIRECCION, sobre los LEDs. Cuando el botn GRABAR
es pulsado, el valor del DIP-SWITCH, DATOS es grabado en la direccin actual. Los pines de
Reloj, y Datos para este PIC, ya estn predefinidos por el fabricante por los pines RC3, y RC4
respectivamente.
7.2 Mdulo USART
La USART, es un mdulo de comunicacin serial estndar, de forma asncrona, est
caracterstica lo hace muy apetecido dado que requiere un solo medio de transmisin para enviar
informacin, y no requiere un medio para el reloj. La seal de reloj, o sincronismo lo deben
asumir, independiente mente cada uno de los elementos, el transmisor y el receptor. Otra ventaja
de este mdulo es que cuenta con comunicacin full-duplex, es decir que puede transmitir y
recibir informacin al mismo tiempo. Para este propsito se usan dos medios de transmisin
dedicados, uno solo para transmitir y uno solo para recibir.

La comunicacin sncrona cuenta con las siguientes caractersticas: un bit de inicio o de start, que
siempre es un 0 lgico, 8 o 9 bits de datos para el caso puntual de los PIC, y 1, 1.5 o 2 bits de fin
o stop. Por ltimo la velocidad de transmisin que debe estr definida con el mismo valor en los
dos dispositivos que se comunican, est por defecto en casi toda comunicacin es de 9600 bps,
sin embargo esto no es una regla puede ser mayor o menor.

En la siguiente grfica se puede apreciar el comportamiento de la transmisin de un dato con este
protocolo:

92


Figura 7-3

Este protocolo es utilizado por los ordenadores personales y otros dispositivos, y se conoce como
RS232, para el caso puntual de este los niveles de tensin elctrica son diferentes al
microcontrolador. El protocolo RS232, representa el valor de un 0 lgico con una tensin de +12
voltios, y el valor de un 1 lgico con -12 voltios. Los ordenadores personales y los dems
dispositivos que implementan el puerto RS232, usan un conector DB9, que tiene 9 pines, los
cuales se identifican en la siguiente figura:



Figura 7-4

Pin Uso
1 DCD
2 RXD
3 TXD
4 DTR
5 GND
6 DSR
7 RTS
8 CTS
9 No usado

Tabla 7-1

Para fines de comunicacin asncrona se debe configurar las conexiones de la siguiente forma:



Figura 7-5
93
Para estblecer y acoplar la comunicacin de un PIC, con un dispositivo RS232, se debe usar un
convertidor conocido como MAX232. La implementacin de este, se debe hacer como se aprecia
en la siguiente figura:


Circuito 7-2

Para el uso de este protocolo de comunicacin el compilador MikroC PRO, cuenta con la librera:
UART, est disponible en la paleta de libreras y cuenta con las siguientes funciones para su uso:

UART1_Init(const unsigned long baud_rate);, Est funcin inicializa el mdulo USART, y
estblece la velocidad de comunicacin definida en el parmetro: baud_rate.
La funcin: char UART1_Data_Ready();, est funcin determina si hay un dato listo para ser
ledo, en el bfer de llegada del mdulo, si la funcin retorna 1 el dato puede ser ledo, de lo
contrario no hay datos nuevos en el bfer.
La funcin: char UART1_Tx_Idle();, est funcin estblece si el bfer de transmisin se
encuentra ocupado enviando un dato, para esto retorna 1 si el bfer est ocupado, o 0 si el
mdulo est disponible para enviar un nuevo dato.
La funcin: char UART1_Read();, est funcin retorna el valor del bfer de entrada, es decir que
sirve para leer un dato de entrada.
La funcin: UART1_Read_Text(char *Output, char *Delimiter, char Attempts);, est funcin lee
una cadena de caracteres y la guarda en el apuntador Output, el apuntador Delimiter, es un
apuntador a una cadena de caracteres que contiene el texto definido como fin de la cadena de
texto de entrada, el parmetro Attempts, define la longitud de la cadena de caracteres del
delimitador de fin de cadena Delimiter.
La funcin: UART1_Write(char _data);, transmite el dato _data ingresado en el parmetro de
entrada, por la USART.
94
La funcin: UART1_Write_Text(char * UART_text);, Transmite una cadena de texto finalizada
con el carcter nulo o 0. Est cadena de texto es entregada por medio del parmetro UART_text.
Para realizar el siguiente ejemplo se debe implementar en ISIS, el circuito con los siguientes
dispositivos: PIC 16F877A, y el instrumento virtual: VIRTUAL TERMINAL. Con estos dos
elementos se construye el siguiente circuito:

Circuito 7-3
El instrumento VIRTUAL TERMINAL, es un simulador de comunicacin serial y tiene un
comportamiento similar a la herramienta HiperTerminal de Windows. Este instrumento permite
editar las caractersticas de la comunicacin como: el nmero de bits de datos, la velocidad de
transmisin, el nmero de bits de parada, entre otros. Sin embargo el instrumento est
configurado por defecto con una velocidad de 9600 bps, y caractersticas listas para usar con la
USART del PIC.
Para comprobar el funcionamiento de este mdulo se puede compilar y simular el siguiente
ejemplo:

void main( void )
{
//Declaracin de variables.
char DATO;
UART1_Init(9600); //Inicio del mdulo USART.
//Se transmite el texto: de bienvenida.
UART1_Write_Text("Bienvenido al simulador:");
UART1_Write(13); //Se transmite el ASCII del ENTER.
UART1_Write(10); //Se transmite el ASCII del retroceso del carro.
//Se trasmite el texto de pulsar tecla.
UART1_Write_Text("Pulse una tecla!...");
95
UART1_Write(13); //Se transmite el ASCII del ENTER.
UART1_Write(10); //Se transmite el ASCII del retroceso del carro.
while(1)//Bucle infinito.
{
//La sentencia if evala si un dato est listo para leer.
if(UART1_Data_Ready()==1)
{
//Se lee el DATO del bufer.
DATO = UART1_Read();
//Se imprime el texto de realimentacin.
UART1_Write_Text("Usted pulso la tecla: ");
UART1_Write(DATO); //Se transmite el DATO recibido.
UART1_Write(13); //Se transmite el ASCII del ENTER.
UART1_Write(10); //Se transmite el ASCII del retroceso del carro.
}
}
}

Durante la simulacin el usuario puede enviar datos por el terminal virtual y ver la realimentacin
que el PIC, emite.
7.3 Mdulo USB
La comunicacin USB, es de gran utilidad para realizar aplicaciones que impliquen la
transmisin de datos con un ordenador personal. La desventaja ms notable de este mdulo es
que solo est disponible en pocos microcontroladores como los PIC 18F2550 y 18F4550. Sin
embargo estos microcontroladores tienen caractersticas poderosas que los hacen ideales para la
mayora de las aplicaciones.

En las siguientes grficas se puede apreciar las terminales de los conectores USB:


Figura 7-6

Pin Uso
1 Vcc +5 Voltios
2 Dato -
3 Dato +
4 Gnd

Tabla 7-2
96
Una ventaja de la conexin USB, es que puede entregar una alimentacin de 5 voltios con una
corriente mxima de 500mA, esto significa que si el desarrollo no supera este consumo, no es
necesario implementar una fuente de poder externa.

El paso siguiente es realizar un circuito en ISIS, que permita correr la simulacin del ejemplo.
Para este caso se usa un PIC 18F2550, para este fin se requiere este dispositivo, el puerto virtual
USBCONN, un LED LED-RED, y RES. Para usar este tipo de simulacin se debe asegurar la
instalacin de los controladores USB, del simulador ISIS. Para hacer est instalacin se busca el
directorio de instalacin de Proteus, y correr la instalacin de los controladores. La ubicacin por
defecto de estos controladores es la siguiente:
C:/labcenter Electronics/Proteus 7 Professional/USB Drivers/installer.exe
Posteriormente se debe hacer el siguiente circuito:


Circuito 7-4

Para fines prcticos en el terminal VUSB, se debe instalar un capacitor de 33uF conectado a
referencia. Y se debe usar un cristal de cuarzo adecuado a las caractersticas de diseo. La opcin
de edicin para los fusibles del PIC 18F2550, es de suma complejidad en comparacin con los
micros de baja gama. La configuracin se edita picando el men: proyect en el compilador
MikroC PRO, y dentro de este men se pica el submen, Edit Proyect est accin despliega
una ventana de edicin la cual debe quedar de la siguiente forma:



97


Figura 7-7

98
Para fines prcticos se debe asegurar en la simulacin una fuente de reloj de 48Mhz y en un
circuito real se usa un cristal de 4Mhz, esto se debe a que el microcontrolador posee un PLL
interno que multiplica la frecuencia.

El cdigo fuente de MikroC PRO, es el siguiente:

//Declaracin de variables globales
//como bfer de entrada y salida en el USB.
unsigned short Br[64];
unsigned short Bw[64];

//Funcin de rutina USB
//dentro de las interrupciones.
void HID_Inte( void )
{
asm CALL _Hid_InterruptProc
asm nop
}

//Funcin de interrupciones.
void interrupt( void )
{
HID_Inte();
}

void main( void )
{
//Declaracin de variables.
unsigned short n;
char DATO;
//Configuracin del PIC, e interrupciones.
INTCON = 0;
INTCON2 = 0xF5;
INTCON3 = 0xC0;
RCON.IPEN = 0;
PIE1 = 0;
PIE2 = 0;
PIR1 = 0;
PIR2 = 0;
//Configuracin de puertos.
TRISB = 0;
PORTB = 0;

Hid_Enable(&Br,&Bw);//Funcin de inicio para el puerto USB.
//Ciclo for para inicializar el bfer en 0.
for(n=0; n<64; n++)Bw[n]=0;

while(1) //Bucle infinito.
{
99
//Funcin para verificar los datos de entrada.
n=Hid_Read();
//Sentencia if para verificar el nmero bytes de entrada.
if( n!=0 )
{
PORTB = 255; //Se prende todo el puerto B
DATO = Br[0]; //Se lee el dato de entrada.
//Se copia el texto, en el bfer de salida.
strcpy( Bw, "Se recibio el dato: " );
//Se copia el dato de entrada en el bfer.
Bw[20]=DATO;
//Se anexa el cdigo ASCCI del ENTER en el bfer de salida.
Bw[21]=13;
//Se anexa el cdigo ASCCI del retroceso del carro en el bfer de salida.
Bw[22]=10;
//Se envan los datos por el USB.
HID_Write(Bw,64);
delay_ms(100); //Retardo para el parpadeo del LED.
PORTB = 0; //Se apaga el puerto B.
}
}
}

La configuracin de los proyectos que usen la librera USB, es tediosa pero finalmente solo
recurren a cuatro funciones para su uso. Ests funciones son las siguientes:

Hid_Enable(unsigned *readbuff, unsigned *writebuff);, est funcin configura el mdulo USB,
y estblece la comunicacin con la computadora. Incluye los parmetros de entrada readbuff y
writebuff, que son apuntadores a los arreglos de memoria que guardan y transmiten la
informacin por el puerto USB.
La funcin: unsigned char Hid_Read(void);, est funcin retorna la cantidad de datos listos para
ser ledos del puerto USB.
La funcin: unsigned short Hid_Write(unsigned *writebuff, unsigned short len);, est funcin
escribe en el puerto USB, la cantidad de bytes definidos en el parmetro len, que estn
consignados en el apuntador writebuff.
La funcin: void Hid_Disable(void);, est funcin deshabilita el uso del puerto USB.
Para verificar el funcionamiento de este ejemplo se debe correr la simulacin y esperar a que el
dispositivo USB, se instale automticamente, dado que es un dispositivo de interfaz humana,
compatible con Windows. Para enviar datos a la simulacin se requiere correr una aplicacin que
viene con las herramientas de MikroC PRO. Est herramienta se encuentra en Tools, y se pica el
submen, HID Terminal. Para garantizar la correcta compilacin del proyecto, y el uso de la
librera USB, se requieren tres archivos adicionales: USBdsc.c, Definit.h, y VARs.h. El archivo
USBdsc.c contiene las definiciones con las que el ordenador reconoce el dispositivo HID. Tiene
parmetros como el nombre del fabricante, el nombre del producto, los identificadores numricos
de fabricante y producto: VIP y PID. Tambin contiene el tamao de los bfer de entrada y
100
salida. El HID Terminal cuenta con una pesta descriptor. En est pesta se editan las
caractersticas del dispositivo HID, y luego se pulsa el botn Save Descriptor. Est accin
permite guardar el archivo que deben ser archivados en el directorio donde se guarda todo el
proyecto, adems debe ser anexado al proyecto por medio del siguiente icono: de la misma
forma se deben pegar en el directorio los archivos: Definit.h, y VARs.h, estos no requieren ser
anexados solo deben ser pegados. Estos archivos contienen el siguiente cdigo:

Definit.h:

#defineEP0_PACKET_SIZE 8 // EP0 In & Out transfer size
#defineHID_PACKET_SIZE 64 // EP1 In & Out transfer size

//******************************************
//
// Definitions
//
//********************************************
#defineUSB_BUS_ATTACHED 1
#defineUSB_BUS_DETACHED 0

#defineUSB_DEVICE_DESCRIPTOR_LEN 0x12
#defineUSB_CONFIG_DESCRIPTOR_LEN 0x09
#defineUSB_INTERF_DESCRIPTOR_LEN 0x09
#defineUSB_ENDP_DESCRIPTOR_LEN 0x07
#defineUSB_HID_DESCRIPTOR_LEN 0x09

#defineUSB_DEVICE_DESCRIPTOR_TYPE 0x01
#defineUSB_CONFIG_DESCRIPTOR_TYPE 0x02
#defineUSB_STRING_DESCRIPTOR_TYPE 0x03
#defineUSB_INTERFACE_DESCRIPTOR_TYPE 0x04
#defineUSB_ENDPOINT_DESCRIPTOR_TYPE 0x05
#defineUSB_POWER_DESCRIPTOR_TYPE 0x06
#defineUSB_HID_DESCRIPTOR_TYPE 0x21

#defineUSB_ENDPOINT_TYPE_CONTROL 0x00
#defineUSB_ENDPOINT_TYPE_ISOCHRONOUS 0x01
#defineUSB_ENDPOINT_TYPE_BULK 0x02
#defineUSB_ENDPOINT_TYPE_INTERRUPT 0x03

#defineDSC_DEV 0x01
#defineDSC_CFG 0x02
#defineDSC_STR 0x03
#defineDSC_INTF 0x04
#defineDSC_EP 0x05



//******************************************
//
101
// Definitions (added 19.06.2007)
//
//*******************************************************
#define ConfigDescr_OFFS 0x24 // 0x12
#define HID_Descriptor_OFFS 0x48 // 0x24
#define HID_ReportDesc_OFFS 0x76 // 0x3B

#define USB_DEVICE_DESCRIPTOR_ALL_LEN 0x6A



//******************************************************
//
// USBdrv.h
//
//***************************************
// * UCFG Initialization Parameters
#define _PPBM0 0x00 // Pingpong Buffer Mode 0
#define _PPBM1 0x01 // Pingpong Buffer Mode 1
#define _PPBM2 0x02 // Pingpong Buffer Mode 2
#define _LS 0x00 // Use Low-Speed USB Mode
#define _FS 0x04 // Use Full-Speed USB Mode
#define _TRINT 0x00 // Use internal transceiver
#define _TREXT 0x08 // Use external transceiver
#define _PUEN 0x10 // Use internal pull-up resistor
#define _OEMON 0x40 // Use SIE output indicator
#define _UTEYE 0x80 // Use Eye-Pattern test

// * UEPn Initialization Parameters
#defineEP_CTRL 0x06 // Cfg Control pipe for this ep
#defineEP_OUT 0x0C // Cfg OUT only pipe for this ep
#defineEP_IN 0x0A // Cfg IN only pipe for this ep
#defineEP_OUT_IN 0x0E // Cfg both OUT & IN pipes for this ep
#defineHSHK_EN 0x10 // Enable handshake packet

#defineOUT 0
#defineIN 1

#definePIC_EP_NUM_MASK 0x78
#definePIC_EP_DIR_MASK 0x04

#defineEP00_OUT 0x00 // (0x00<<3) | (OUT<<2)
#defineEP00_IN 0x04 // (0x00<<3) | ( IN<<2)
#defineEP01_OUT 0x08 // (0x01<<3) | (OUT<<2)
#defineEP01_IN 0x0C // (0x01<<3) | ( IN<<2)
#defineEP02_OUT 0x10 // (0x02<<3) | (OUT<<2)
#defineEP02_IN 0x14 // (0x02<<3) | ( IN<<2)
#defineEP03_OUT 0x18 // (0x03<<3) | (OUT<<2)
#defineEP03_IN 0x1C // (0x03<<3) | ( IN<<2)
102
#defineEP04_OUT 0x20 // (0x04<<3) | (OUT<<2)
#defineEP04_IN 0x24 // (0x04<<3) | ( IN<<2)
#defineEP05_OUT 0x28 // (0x05<<3) | (OUT<<2)
#defineEP05_IN 0x2C // (0x05<<3) | ( IN<<2)
#defineEP06_OUT 0x30 // (0x06<<3) | (OUT<<2)
#defineEP06_IN 0x34 // (0x06<<3) | ( IN<<2)
#defineEP07_OUT 0x38 // (0x07<<3) | (OUT<<2)
#defineEP07_IN 0x3C // (0x07<<3) | ( IN<<2)
#defineEP08_OUT 0x40 // (0x08<<3) | (OUT<<2)
#defineEP08_IN 0x44 // (0x08<<3) | ( IN<<2)
#defineEP09_OUT 0x48 // (0x09<<3) | (OUT<<2)
#defineEP09_IN 0x4C // (0x09<<3) | ( IN<<2)
#defineEP10_OUT 0x50 // (0x0A<<3) | (OUT<<2)
#defineEP10_IN 0x54 // (0x0A<<3) | ( IN<<2)
#defineEP11_OUT 0x58 // (0x0B<<3) | (OUT<<2)
#defineEP11_IN 0x5C // (0x0B<<3) | ( IN<<2)
#defineEP12_OUT 0x60 // (0x0C<<3) | (OUT<<2)
#defineEP12_IN 0x64 // (0x0C<<3) | ( IN<<2)
#defineEP13_OUT 0x68 // (0x0D<<3) | (OUT<<2)
#defineEP13_IN 0x6C // (0x0D<<3) | ( IN<<2)
#defineEP14_OUT 0x70 // (0x0E<<3) | (OUT<<2)
#defineEP14_IN 0x74 // (0x0E<<3) | ( IN<<2)
#defineEP15_OUT 0x78 // (0x0F<<3) | (OUT<<2)
#defineEP15_IN 0x7C // (0x0F<<3) | ( IN<<2)
//****************************************
//
// USBmmap.h
//
//***********************************************
// * Buffer Descriptor Status Register Initialization Parameters
#define_BC89 0x03 // Byte count bits 8 and 9
#define_BSTALL 0x04 // Buffer Stall enable
#define_DTSEN 0x08 // Data Toggle Synch enable
#define_INCDIS 0x10 // Address increment disable
#define_KEN 0x20 // SIE keeps buff descriptors enable
#define_DAT0 0x00 // DATA0 packet expected next
#define_DAT1 0x40 // DATA1 packet expected next
#define_DTSMASK 0x40 // DTS Mask
#define_USIE 0x80 // SIE owns buffer
#define_UCPU 0x00 // CPU owns buffer
// * USB Device States - To be used with [byte usb_device_state]
#defineDETACHED_STATE 0
#defineATTACHED_STATE 1
#definePOWERED_STATE 2
#defineDEFAULT_STATE 3
#defineADR_PENDING_STATE 4
#defineADDRESS_STATE 5
#defineCONFIGURED_STATE 6
// * Memory Types for Control Transfer - used in USB_DEVICE_STATUS
103
#define_RAM 0
#define_ROM 1
#defineRemoteWakeup 0
#definectrl_trf_mem 1
//*****************************************
//
// USBctrlTrf.h
//
//***************************************
// * Control Transfer States
#define WAIT_SETUP 0
#define CTRL_TRF_TX 1
#define CTRL_TRF_RX 2
// * USB PID: Token Types - See chapter 8 in the USB specification
#define SETUP_TOKEN 0x0D
#define OUT_TOKEN 0x01
#define IN_TOKEN 0x09
// * bmRequestType Definitions
#define HOST_TO_DEV 0
#define DEV_TO_HOST 1

#define STANDARD 0x00
#define CLASS 0x01
#define VENDOR 0x02

#define RCPT_DEV 0
#define RCPT_INTF 1
#define RCPT_EP 2
#define RCPT_OTH 3
//******************************
//
// USBcfg.h
//
//***********************************************************
// * MUID = Microchip USB Class ID
// * Used to identify which of the USB classes owns
// the current session of control transfer over EP0
#defineMUID_NULL 0
#defineMUID_USB9 1
#defineMUID_HID 2
//***************************************************
//
// USB9.h
//
//*****************************************************
// * Standard Request Codes, USB 2.0 Spec Ref Table 9-4
#defineGET_STATUS 0
#defineCLR_FEATURE 1
#defineSET_FEATURE 3
104
#defineSET_ADR 5
#defineGET_DSC 6
#defineSET_DSC 7
#defineGET_CFG 8
#defineSET_CFG 9
#defineGET_INTF 10
#defineSET_INTF 11
#defineSYNCH_FRAME 12
// * Standard Feature Selectors
#define DEVICE_REMOTE_WAKEUP 0x01
#define ENDPOINT_HALT 0x00
//********************************************
//
// HID.h
//
//********************************************
#defineHID_INTF_ID 0x00
// * Class-Specific Requests
#defineGET_REPORT 0x01
#defineGET_IDLE 0x02
#defineGET_PROTOCOL 0x03
#defineSET_REPORT 0x09
#defineSET_IDLE 0x0A
#defineSET_PROTOCOL 0x0B
// * Class Descriptor Types
#defineDSC_HID 0x21
#defineDSC_RPT 0x22
#defineDSC_PHY 0x23
//********************************************

VARs.h:

//*********************************************
//
// Bank 4 GPR Variables in region 0x400 - 0x4FF
//
//**********************************************
extern unsigned char BDT[16];
extern unsigned char SetupPkt[8];
extern unsigned char CtrlTrfData[8];
extern unsigned char hid_report_feature[8];

extern unsigned char Byte_tmp_0[2];
extern unsigned char Byte_tmp_1[2];
extern unsigned char param_Len;
extern unsigned char param_buffer[2];
extern unsigned char USTAT_latch;
extern unsigned char usb_device_state;
extern unsigned char usb_active_cfg;
105
extern unsigned char usb_alt_intf[2];
extern unsigned char usb_stat;
extern unsigned char idle_rate;
extern unsigned char active_protocol;
extern unsigned char hid_rpt_rx_len;
extern unsigned char ctrl_trf_state;
extern unsigned char ctrl_trf_session_owner;
extern unsigned char pSrc[2];
extern unsigned char pDst[2];
extern unsigned char wCount[2];
extern unsigned char byte_to_send[2];
extern unsigned char byte_to_read[2];
extern unsigned char number_of_bytes_read;

extern unsigned char USB_CD_Ptr[4];
extern unsigned char USB_SD_Ptr[8];

extern char FSR0reg[2];
extern char FSR1reg[2];
extern char FSR2reg[2];

extern unsigned int HID_ReadBuff_Ptr;
extern unsigned int HID_WriteBuff_Ptr;

extern unsigned char hid_report_out[64];
extern unsigned char hid_report_in[64];

//********************************************
// Setup packet structures in EP0 Out Buffer
//********************************************
extern unsigned char SetupPkt_bmRequestType;
extern unsigned char SetupPkt_bRequest;
extern unsigned int SetupPkt_wValue;
extern unsigned int SetupPkt_wIndex;
extern unsigned int SetupPkt_wLength;
extern unsigned int SetupPkt_W_Value;
extern unsigned int SetupPkt_W_Index;
extern unsigned int SetupPkt_W_Length;
extern unsigned char SetupPkt_Recipient;
extern unsigned char SetupPkt_RequestType;
extern unsigned char SetupPkt_DataDir;
extern unsigned char SetupPkt_bFeature;
extern unsigned char SetupPkt_bDscIndex;
extern unsigned char SetupPkt_bDscType;
extern unsigned int SetupPkt_wLangID;
extern unsigned char SetupPkt_bDevADR;
extern unsigned char SetupPkt_bDevADRH;
extern unsigned char SetupPkt_bCfgValue;
extern unsigned char SetupPkt_bCfgRSD;
106
extern unsigned char SetupPkt_bAltID;
extern unsigned char SetupPkt_bAltID_H;
extern unsigned char SetupPkt_bIntfID;
extern unsigned char SetupPkt_bIntfID_H;
extern unsigned char SetupPkt_bEPID;
extern unsigned char SetupPkt_bEPID_H;
extern unsigned char SetupPkt_EPNum;
extern unsigned char SetupPkt_EPDir;
//**************************************
// Buffer Descriptors Table
//**************************************
extern unsigned char BD0STAT;
extern unsigned char BD0CNT;
extern unsigned char BD0ADRL;
extern unsigned char BD0ADRH;
extern unsigned char BD1STAT;
extern unsigned char BD1CNT;
extern unsigned char BD1ADRL;
extern unsigned char BD1ADRH;
extern unsigned char BD2STAT;
extern unsigned char BD2CNT;
extern unsigned char BD2ADRL;
extern unsigned char BD2ADRH;
extern unsigned char BD3STAT;
extern unsigned char BD3CNT;
extern unsigned char BD3ADRL;
extern unsigned char BD3ADRH;
extern unsigned char BD4STAT;
extern unsigned char BD4CNT;
extern unsigned char BD4ADRL;
extern unsigned char BD4ADRH;
extern unsigned char BD5STAT;
extern unsigned char BD5CNT;
extern unsigned char BD5ADRL;
extern unsigned char BD5ADRH;
extern unsigned char BD6STAT;
extern unsigned char BD6CNT;
extern unsigned char BD6ADRL;
extern unsigned char BD6ADRH;
extern unsigned char BD7STAT;
extern unsigned char BD7CNT;
extern unsigned char BD7ADRL;
extern unsigned char BD7ADRH;
//***********************************
//***********************************
// Initialization Function
//***********************************
void InitVARs();
//***********************************
107
Para la creacin del proyecto el editor HID Terminal debe tener una vista como la siguiente antes
de realizar la creacin del archivo USBdsc.c:

Figura 7-8

Despus de correr la simulacin se debe correr el HID Terminal, y seleccionar la pesta:
Terminal. Est aplicacin permite enviar y recibir datos por medio del puerto USB. Para este
propsito, se debe seleccionar el dispositivo, Picando el nombre del dispositivo en la lista HID
Devices, para este caso el nombre del dispositivo es: Prueba USB. Posteriormente se escribe un
carcter en la casilla de envi de datos y se pulsa el botn Send. Seguidamente el PIC retransmite
un texto con el carcter enviado, y el LED del circuito hace un parpadeo. Una vista de est accin
en el HID Terminal tiene la siguiente apariencia:

Figura 7-9
108
De igual manera si se pulsa el botn: info, el HID Terminal muestra en una ventana las
caractersticas con las que est configurado en dispositivo HID, una vista de est accin se puede
apreciar en la siguiente figura:


Figura 7-10



109
8 Conversin AD y DA
La conversin anlogo digital y digital anlogo es un proceso por el cual se puede tomar o
entregar muestras de una seal continua de voltaje. El uso de ests conversiones es de gran
utilidad para realizar procesamiento digital de seales. La conversin anlogo digital, o ADC, se
puede realizar con algunos microcontroladores que tienen implcito un convertidor de este estilo.
El proceso de conversin digital anlogo es posible con elementos externos de fcil
implementacin o, incluso, es posible realizar esta conversin con los mdulos PWM
incorporados en algunos microcontroladores.
8.1 Conversin AD, o ADC
Este proceso se realiza con el convertidor interno de los microcontroladores. Este mdulo est
incorporado en la mayora de los microcontroladores de gama media y alta. La conversin
implementada por los PICMicro cuenta con una resolucin de 10 bits, lo que permite obtener un
nmero con un rango de 0 a 1023, que es proporcional a los valores de referencia, que por
defecto son 0 voltios y 5 voltios. Esto significa que si una entrada anloga, tiene una tensin de 0
voltios su resultado es 0, y si la tensin es de 5 voltios el resultado de la conversin es 1023 de
igual manera si la tensin es de 2.5 voltios, el resultado ser 512. Dependiendo de la complejidad
del microcontrolador un PIC puede tener hasta 8 entradas de seal anloga. Sin embargo cabe
denotar que el mdulo de conversin interna de los microcontroladores es slo uno, y los
mltiples canales se pueden leer pero no al mismo tiempo. Para realizar este tipo de conversiones
el compilador MikroC PRO cuenta con una librera definida: ADC para hacer la conversin. Est
librera cuenta con una sola funcin denominada unsigned int ADC_Read(unsigned short
channel). Esta funcin retorna el resultado de la conversin del canal especificado por el
parmetro channel. Para contextualizar el uso de est librera se puede observar y analizar el
siguiente ejemplo:
void main( void )
{
//Declaracin de variables.
unsigned int Dato;
//Inicializacin de puertos.
TRISB = 0;
TRISC = 0;
PORTB = 0;
PORTC = 0;
while(1) //Bucle infinito.
{
Dato = ADC_Read(0); //Se hace conversin sobre el canal 0.
//Se muestran los 8 bits de menor peso por el puerto B.
PORTB = Dato&0xFF;
//Se muestran los 2 bits de mayor peso por el puerto C.
PORTC = (Dato>>8)&0x03;
}
}
110
Para la simulacin de este ejemplo se deben implementar los dispositivos: 16F877A, RES, LED-
RED, POT-HG, en el siguiente circuito de ISIS:


Circuito 8-1

Despus de correr la simulacin los LEDs muestran en cdigo binario del valor de la conversin
anlogo digital, de la diferencia de potencial que entrega el potencimetro.

8.2 Conversin DA o DAC
Este tipo de conversin es posible por medio de dos estrategias, la primera es usar el mdulo
PWM, del microcontrolador, y la segunda es la implementacin de un arreglo externo de
resistencias para obtener la diferencia de potencial.

8.2.1 Conversin DA con PWM
La conversin digital anlogo, con el mdulo PWM, consiste en tomar la seal modulada por
ancho de pulso y realizar la demodulacin por medio de un filtro pasa bajas. Este filtro debe tener
como frecuencia de corte un valor mucho menor a la frecuencia de muestreo en una proporcin
cercana a 10 veces, dado que su objetivo es eliminar la frecuencia de muestreo. El clculo de la
frecuencia de corte de este filtro est regido por la siguiente frmula:


RC
Fc
t 2
1
=
Ecuacin 8-1


El circuito a implementa de un filtro pasa bajas de primer orden es el siguiente:

111

Circuito 8-2

Implementacin del filtro pasa bajas de segundo orden:

Circuito 8-3

La ecuacin para el clculo en este filtro es:
2 2
1
RC
Fc
t
= Ecuacin 8-2

La frecuencia que se asigne a la portadora de modulacin PWM, debe ser mucho mayor a la
frecuencia de muestreo de la seal moduladora. Para demostrar el funcionamiento en est
conversin se designarn 20 muestras que corresponden a un ciclo de una seal seno. Las
muestras y la forma de onda se pueden apreciar en la siguiente figura:

Figura 8-1
112
La implementacin de la librera PWM, se hace por medio de cuatro funciones que son:
PWM1_Init(const long freq);, est funcin inicializa el mdulo PWM, a la frecuencia de la
portadora freq. La funcin: PWM1_Set_Duty(unsigned short duty_ratio);, est funcin estblece
el ciclo til por medio del parmetro duty_ratio, este parmetro puede tomar valores de 0 a 255,
donde 0 representa el 0%, y 255 el 100% del ciclo til. La siguiente imagen ilustra el
comportamiento de una seal PWM, en funcin del ciclo til, la relacin Fpwm y Tpwm:



Figura 8-2

Por ltimo se cuenta con las funciones: PWM1_Start(); y PWM1_Stop();, Las cuales activan y
desactivan respectivamente la seal PWM.

Para realizar la simulacin se debe hacer un proyecto en MikroC PRO, con el siguiente cdigo
fuente:


//Declaracin de constantes
//para la seal seno.
const unsigned short Seno[20] =
{
127, 146, 163, 177, 185, 189, 185,
177, 163, 146, 127, 107, 90, 76,
68, 65, 68, 76, 90, 107
};


void main( void )
{
//Declaracin de variables.
unsigned short n=0;
//Configuracin del mdulo PWM a Fpwm=15.625K Hz.
PWM1_Init(15625);
//Inicio de seal PWM.
PWM1_Start();
while(1) //Bucle infinito.
{
//Bucle para recorres las 20 muestras
//de un ciclo para la onda seno.
for( n=0; n<20; n++ )
113
{
//Cambio del ciclo til del PWM.
PWM1_Set_Duty( Seno[n] );
//Retardo de 50u seg.
delay_us(50);
}
}
}


La ejecucin de la simulacin requiere de los dispositivos: 16F877A, RES, CAP, OP1P, y el
instrumento virtual: OSCILLOSCOPE. Este ltimo es un osciloscopio virtual de 4 canales
simultneos, ideal para visualizar seales anlogas e incluso digitales.

Este circuito implementa un filtro pasa bajas para eliminar la frecuencia Fpwm portadora que en
este caso es de 15.6KHz, el filtro cuenta con una frecuencia de corte de 1.5KHz
aproximadamente.

En futuras aplicaciones se recomienda para los clculos de los filtros, definir un valor arbitrario
para el condensador C, entre 100nF y 100pF y calcular el valor de R, por medio de las ecuaciones
antes mencionadas.
Con los anteriores elementos se construye el siguiente circuito:


Circuito 8-4

Sobre la marcha de la simulacin se debe apreciar como emerge el osciloscopio virtual
mostrando la seal anloga de forma seno producto de la reconstruccin digital del PIC, por
medio del mdulo PWM, y el filtro pasa bajas, la apariencia visual del osciloscopio es la que se
puede ver en la siguiente figura:

114

Figura 8-3
8.2.2 Conversin DA con arreglo R-2R
El arreglo de resistencias R-2R, permite hacer la conversin de un nmero binario a un valor
proporcional de voltaje. Este arreglo permite implementar un nmero indeterminado de bits, en la
conversin a diferencia del mdulo PWM, que se limita a 8 bits. Esto quiere decir que con el
arreglo R-2R, se pueden hacer conversiones de 8, 16, 32, 64, o un nmero n de bits en funcin de
la cantidad de pines disponibles en un microcontrolador. La implementacin del convertidor R-
2R, es de fcil desarrollo dado que consiste en un arreglo de conexiones de resistencias, donde
una es el doble de la otra, de ah su nombre R-2R.
Cabe resaltar que cuantos ms bits, posea la conversin mayor ser su resolucin y por
consiguiente mayor la calidad de la seal reconstruida. Las desventajas notables de este arreglo
son, el incremento del hardware requerido y el uso de una cantidad mayor de pines de los puertos.
En la siguiente grfica se puede apreciar la configuracin de las resistencias para una conversin
de 8 bits:


Circuito 8-5

Este arreglo puede ser expandido con la misma arquitectura para conseguir hacer un convertidor
de mayor resolucin, aumentando el nmero de entadas D, o lo que es igual el nmero de bits.
Otra caracterstica de este tipo de conversin es que no requiere de libreras especializadas, solo
basta con colocar el valor numrico a convertir en un puerto, y el valor anlogo har presencia en
la salida. De la misma forma que se hace la conversin por PWM, es importante suprimir la
frecuencia de muestreo para evitar componentes de seal impuras.

115
Una forma completa del convertidor con un acople de impedancia y su respectivo filtro pasa
bajas de 1.5K Hz, es el siguiente:


Circuito 8-6

Para demostrar la aplicacin de est tcnica de conversin se modificar el ejemplo de
conversin con PWM, para este fin observe y analice el siguiente cdigo fuente:

//Declaracin de constantes
//para la seal seno.
const unsigned short Seno[20] =
{
127, 146, 163, 177, 185, 189, 185,
177, 163, 146, 127, 107, 90, 76,
68, 65, 68, 76, 90, 107
};

void main( void )
{
//Declaracin de variables.
unsigned short n=0;
//Configuracin de puertos.
TRISB = 0;
PORTB = 127;
while(1) //Bucle infinito.
{
//Bucle para recorres las 20 muestras
//de un ciclo para la onda seno.
for( n=0; n<20; n++ )
{
//Cambio de muestra en el puerto B.
116
PORTB = Seno[n];
//Retardo de 50u seg.
delay_us(50);
}
}
}

Editado y compilado este programa se procede a simular en ISIS, con el circuito que se puede
apreciar en el siguiente circuito:


Circuito 8-7

El resultado esperado en est simulacin es igual a la simulacin del convertidor con PWM, la
salida del osciloscopio debe mostrar una grfica similar.
117
9 Memorias EEPROM y
FLASH
Las memorias EEPROM y FLASH de los microcontroladores son espacios de memoria que se
pueden programar y borrar elctricamente, ests dos memorias son campos de informacin no
voltil; es decir, que si la energa de alimentacin del microcontrolador se desconecta la
informacin no se pierde. Est informacin puede ser reprogramada alrededor de 100000 veces
para el caso de la memoria FLASH y algo cercano a 1000000 de veces para el caso de las
memorias EEPROM. De igual manera su informacin puede ser garantizada hasta por 40 aos sin
energa elctrica.
9.1 Memoria EEPROM
La memoria EEPROM es un campo relativamente pequeo que tienen los microcontroladores
para que el desarrollador guarde informacin como configuraciones y datos variables que no
deben perderse. La capacidad de memoria vara de un microcontrolador a otro dependiendo de su
gama y tamao. La manipulacin de esta memoria se puede hacer con MikroC PRO, por medio
de una librera llamada: EEPROM, est cuenta con dos funciones que permiten leer y escribir una
direccin de memoria. Las funciones son: unsigned short EEPROM_Read(unsigned int
address);, Est funcin lee y retorna el valor guardado en la direccin especificada en el
parmetro address.
La funcin: EEPROM_Write(unsigned int address, unsigned short data);, est funcin graba la
direccin definida en el parmetro address, con el valor entregado en el parmetro data.

Para entender de forma concreta el funcionamiento de est librera se puede observar y analizar el
siguiente cdigo fuente:

void main( void )
{
//Configuracin de puertos.
TRISB = 0;
PORTB = 0;
while(1) //Bucle infinito.
{
//Se muestra en el puerto B el valor
//de la direccin 0 de la memoria EEPROM.
PORTB = EEPROM_Read(0);
//La sentencia if evala si se pulsa el botn.
if( !PORTC.F0 )
{
//Se incrementa el valor del puerto B.
PORTB++;
//Se guarda el nuevo valor del puerto
//en la direccin 0 de la EERPOM.
EEPROM_Write(0,PORTB);
118
//Se espera a que se suelte el botn.
while( !PORTC.F0 );
}
}
}

La simulacin de este ejemplo se realiza con los dispositivos: 16F877A, RES, LED-RED, y
BUTTON. Para correr la simulacin se debe construir el siguiente circuito en ISIS:


Circuito 9-1

El circuito al ser simulado, mostrar en los LEDs el valor de la direccin 0 de la memoria
EEPROM, este valor es incrementado cada vez que se pulsa el botn, y este es actualizado en la
memoria EEPROM. Durante la simulacin se puede detener la misma, para ver el efecto de la
suspensin de energa, de tal forma que al correr de nuevo la simulacin se puede ver como el
valor de la informacin se conserva.
9.2 Memoria FLASH
La memoria FLASH es el campo de informacin de mayor capacidad de los microcontroladores
es en est memoria donde se guarda las instrucciones de todo el programa del PIC. Esto significa
que es de sumo cuidado usar est memoria ya que es posible daar el programa principal si se
altera alguna de sus instrucciones. La programacin de la memoria FLASH es de utilidad para
guardar segmentos de informacin de tamao relativamente grande. En est memoria se puede
guardar pequeos archivos del orden de 1 o ms kilo bytes dependiendo de la capacidad de
memoria de cada uno de los microcontroladores, y del tamao total del programa, dado que a
medida que el tamao del programa aumenta, la posibilidad de usar la memoria FLASH, se
reduce.

La implementacin de est librera se fundamenta en dos funciones similares a las funciones de la
memoria EEPROM, ests funciones son: FLASH_Write(unsigned address, unsigned int* data);,
en est funcin se ingresa el parmetro address, el cual contiene la direccin de la primera
119
direccin a grabar, y el apuntador data, que contiene los datos que sern grabados en la memoria
FLASH. La siguiente funcin es: unsigned FLASH_Read(unsigned address);, est funcin
retorna el valor guardado en la direccin definida por el parmetro address.

Para contextualizar el uso de est librera se puede crear y analizar el siguiente cdigo de
programa:

void main( void )
{
//Declaracin de variables.
char Dato;
unsigned int buf[10];
unsigned int Dir;
//Configuracin de puertos.
TRISB = 0;
PORTB = 0;
PORTB = 1;
//Configuracin del puerto serial.
UART1_Init(9600);
//Bienvenida al programa.
UART1_Write_Text("Digite su archivo FLASH");
UART1_Write(13);
UART1_Write(10);
//Se configura la direccin inicial de la FLASH.
Dir=0x0200;
while(1) //Bucle infinito.
{
//Sentencia if para evaluar si hay datos para leer
//en el puerto serial.
if( UART1_Data_Ready() )
{
//Se lee el puerto serial.
Dato = UART1_Read();
//Estructura Switch case para evaluar los datos de entrada.
switch( Dato )
{
//Caso de solicitud de envi del archivo
//con el carcter #
case '#': UART1_Write(13);
UART1_Write(10);
UART1_Write_Text("INIDIO DEL ARCHIVO:");
UART1_Write(13);
UART1_Write(10);
//Se configura la direccin inicial de la FLASH.
Dir=0x0200;
//Bucle do while para leer el archivo
//y enviar la informacin.
do
{
120
//Lectura de la direccin en FLASH.
buf[0]=FLASH_Read(Dir++);
Dato = buf[0];
//Envi del Dato por el puerto serial.
UART1_Write(Dato);
}while( Dato!=0 );
UART1_Write(13);
UART1_Write(10);
UART1_Write_Text("FIN DEL ARCHIVO.");
UART1_Write(13);
UART1_Write(10);
//Se configura la direccin inicial de la FLASH.
Dir=0x0200;
break;

default: //Caso por defecto en donde se guardan
//los datos en la FLASH.
Buf[0]=Dato;
Buf[1]=0; //Carcter fin de cadena NULL.
//Envi de eco por el puerto serial.
UART1_Write(Dato);
//Se guarda en FLASH el dato.
FLASH_Write( Dir, Buf );
//Incremento de la direccin.
Dir++;
}
}
}
}

Para la simulacin en ISIS, se debe implementar los dispositivos 16F877A, y el VIRTUAL
TERMINAL, en un circuito como el que se puede apreciar en la siguiente figura:

Circuito 9-2
121
10 Mdulos Timer
Los mdulos Timer son unidades que permiten hacer el conteo de tiempos precisos, la cantidad
de mdulos Timer en cada microcontrolador depende de la gama del PIC, algunos pueden tener
hasta 4 Timers, sin embargo la mayora de los microcontroladores posee al menos uno que
generalmente se denomina Timer 0. El uso y configuracin de cada mdulo Timer depende del
desarrollador y del tamao del conteo, este conteo puede ser de 8 o 16 bits. El intervalo de tiempo
con el cual se incrementa el Timer, depende de la arquitectura y configuracin que se asigne en
los registros de control del Timer. Para el caso del PIC 16F877A, la arquitectura del Timer 0 es
como se puede apreciar en la siguiente figura:


Figura 10-1

Este mdulo Timer, puede tener dos fuentes de pulsos de reloj, uno es el reloj propio del
procesador, o una fuente externa de reloj, por medio del pin RA4. De igual manera la seal de
reloj puede usar una subdivisin, para crear tiempo de reloj menor. Las subdivisiones posibles
para este timer son las siguientes: 1, 2, 4, 8, 16, 32, 64, 128, y 256. Para el caso de el Timer 0 su
registro es de 8 bits, esto quiere decir que puede hacer un conteo de 0 a 255, y cuando el timer
pasa de 255 a 0, se dice que el Timer se desborda o se dispara.

En funcin de ests caractersticas el tiempo de desborde o disparo se puede calcular con la
siguiente relacin: P = 256x(Subdivisin)x4xTosc, donde Tosc es el periodo de oscilacin del
reloj del procesador, si el Timer 0 se configura con la fuente externa la relacin es:
P = 256x(Subdivisin)xText, donde Text, es el periodo de oscilacin del reloj externo.
Para un reloj de 4MHz, el mayor tiempo puede ser: P=256x256x4x1u, P=65,536m Seg.

122
La configuracin del Timer 0 se logra con los bits: T0CS, PSA, PS0, PS1, y PS2. La calibracin
de la subdivisin del Timer 0 se hace con los bits, PS0, PS1, y PS2, est configuracin obedece a
la siguiente relacin:
Subdivisin Timer 0
PS2:PS1:PS0 Subdivisin
000 2
001 4
010 8
011 16
100 32
101 64
110 128
111 256

Tabla 10-1

Para seleccionar la subdivisin 1, se debe configura el bit PSA, el cual asumen la subdivisin 1,
cuando este bit vale 1, y a sume la subdivisin de la tabla anterior, cuando este bit vale 0.

La configuracin de los bits PS0 al PS2, se realiza sobre el registro OPTION_REG, en los tres
bits de menor peso, el bit PSA, corresponde al cuarto bit del registro OPTION_REG, y el bit
T0SC corresponde al sexto bit del mismo registro. El mapa de bits del registro OPTION_REG, es
el siguiente:

OPTION_REG
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
RBPU INTEDG T0CS T0SE PSA PS2 PS1 PS0

Para demostrar el uso del Timer 0, se puede observar y analizar el siguiente cdigo fuente:

void main( void )
{
TRISB = 0;//Configuracin de puertos.
PORTB = 0;
OPTION_REG=0b11000111; //Configuracin del Timer 0.
while(1) //Bucle infinito.
{
if(TMR0==0) //Se evala si el Timer 0 vale 0.
{
if(PORTB==0)//Se conmuta el valor del puerto B.
PORTB=1;
else
PORTB=0;
while(TMR0==0);//Se espera a que el Timer 0 cambie de valor.
}
}
}
123
Para la simulacin de este circuito en ISIS, se implementan los dispositivos 16F877A, y el
osciloscopio virtual, OSCILLOSCOPE, en el siguiente arreglo:


Circuito 10-1

Al correr la simulacin se puede apreciar en el osciloscopio, que hay un cambio de estado en el
pin RB0, cada 65.536m Seg. La vista del osciloscopio debe ser la siguiente:



Figura 10-2
124
11 Interrupciones
Las interrupciones en los microcontroladores son eventos programados que hacen que el PIC
suspenda su rutina y ejecute un fragmento de programa asociado al evento. Cuando la rutina de la
interrupcin se termina el programa del PIC contina ejecutando el flujo del programa en el
mismo punto en donde se suspendi la ejecucin. Las interrupciones pueden tener fuentes
variadas que dependen de la gama y complejidad del microcontrolador. Por ejemplo el PIC
16F877A cuenta con fuentes de interrupcin como el Timer0, cuando el timer se desborda,
externa cuando se hace un cambio de flanco sobre el pin RB0, serial cuando un dato llega por la
USART, ADC, cuando una conversin termina, entre otras. Para la ejecucin de las
interrupciones el compilador MikroC PRO, cuenta con una funcin predefinida llamada: void
interrupt(void); est funcin debe ser declarada antes de la funcin main. Cuando una
interrupcin se dispara la funcin interrupt es invocada automticamente por el programa, dentro
de est funcin se debe evaluar cual de las interrupciones se dispara por medio de las banderas de
cada interrupcin.

Para la configuracin de las interrupciones se deben activar los bits correspondientes en los
registros de interrupcin En el caso particular del PIC 16F877A se usan los registros: INTCON,
PIR1, PIR2, PIE1, y PIE2. Los mapas de bits de estos registros en el PIC 16F877A son los
siguientes:


INTCON
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
GIE PEIE TMR0IE INTE RBIE TMR0IF INTF RBIF


PIR1
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
PSPIF ADIF RCIF TXIF SSPIF CCP1IF TMR2IF TMR1IF


PIR2
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
- CMIF - EEIF BCLIF - - CCP2IF


PIE1
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
PSPIE ADIE RCIE TXIE SSPIE CCP1IE TMR2IE TMR1IE


PIE2
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
- CMIE - EEIE BCLIE - - CCP2IE

125
La implementacin de las interrupciones implica seguir un protocolo para la correcta
configuracin de las mismas. Primero se deben activar las interrupciones que se desean usar, por
medio de los bit IE, como: TMR0IE, INTE, RCIE, entre otros. Las banderas de disparo de las
interrupciones debe ser desactivadas, como: TMR0IF, INTF, RCIF, entre otras. Se deben activar
las interrupciones perifricas, cuando est se requieran, por ejemplo las que estn citadas en el
registro: PIE1, y PIE2. Por ltimo se debe activar el bit de interrupciones en general, que es: GIE.
Para el siguiente ejemplo se usarn las interrupciones por: recepcin serial, Timer 0, y externa,
para este fin se puede observar y analizar el siguiente cdigo fuente:


//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
//Declaracin de variables usadas en
//la funcin de interrupciones.
char Dato;
//Se evala si la interrupcin disparada es
//por Timer 0, TMR0IF
if( INTCON.F2==1 )
{
//Se complementa el valor del bit RB1.
if(PORTB.F1==1)
PORTB.F1=0;
else
PORTB.F1=1;
//Se apaga la bandera de Timer 0.
INTCON.F2=0;
}


//Se evala si la interrupcin disparada es externa.
// INTF
if( INTCON.F1==1 )
{
//Se complementa el valor del bit RB2.
if(PORTB.F2==1)
PORTB.F2=0;
else
PORTB.F2=1;
//Se apaga la bandera de interrupcin externa.
INTCON.F1=0;
}


//Se evala si la interrupcin disparada por
//recepcin serial.
if( PIR1.F5 )
{
//Se lee el dato de entrada.
126
Dato = UART1_Read();
//Se enva informacin de confirmacin.
UART1_Write_Text("Dato de entrada: ");
//Se enva el dato recibido.
UART1_Write(Dato);
UART1_Write(13); //Se enva cdigo ASCII del enter.
UART1_Write(10); //Se enva cdigo de retroceso del carro.
//Se apara la bandera por recepcin serial.
PIR1.F5 = 0;
}
}


void main( void )
{
//Se configuran los puertos.
TRISB = 0b00000001;
PORTB = 0;
//Se activa la interrupcin por
//recepcin serial.
PIE1 = 0b00100000;
//Se desactivan las dems fuentes de interrupcin.
PIE2 = 0;
//Se apagan las banderas de interrupcin.
PIR2 = 0;
PIR1 = 0;
//Configuracin del Timer 0 a 65,535m Seg.
OPTION_REG=0b11000111;
//Configuracin del puerto serial a 9600 bps.
UART1_Init(9600);
//Se activan las interrupciones globales,
//por Timer 0, y externa.
INTCON = 0b11110000;
while(1) //Bucle infinito.
{

}

}


Para la simulacin de este ejemplo en ISIS, se implementarn los siguientes dispositivos:
16F877A, RES, BUTTON, LED-RED, y los instrumentos virtuales: VIRTUAL TERMINAL y
OSCILLOSCOPE. Despus de correr la simulacin se debe poder interactuar con el virtual
terminal, al enviar datos, con el pulsador se debe conmutar el estdo del LED, y la salida del
osciloscopio debe mostrar una seal cuadrada con cambios cada 65,535m Segundos, de acuerdo
con el Timer 0. Para correr la simulacin se debe hacer el siguiente circuito:


127


Circuito 11-1
128
12 Sensores
La implementacin de sensores en sistemas microcontrolados es de gran utilidad en muchas de
sus aplicaciones, estos permiten obtener lecturas de variables como temperatura, aceleracin,
presin, humedad, velocidad, luminosidad, contraste, entre otras. Su aplicacin es importante en
sistemas de control, robtica, e instrumentacin.
12.1 Sensor de temperatura LM35
El sensor LM35, es un dispositivo activo de 3 terminales que permite adquirir la temperatura
ambiente en rangos de -55 a 150 grados Celsius o centgrados. Este dispositivo es de fcil
implementacin dado que solo cuenta con dos terminales de polarizacin, y una salida de voltaje
directamente proporcional a la temperatura. Este sensor puede ser polarizado de 4 a 30 voltios y
tiene una salida de 10m voltios por cada grado Celsius. La apariencia fsica del sensor y su
distribucin de pines, as como la vista en ISIS, son las que se pueden ver en las siguientes
figuras:

Figura 12-1

Para realizar la lectura del voltaje de salida del sensor se implementa en el microcontrolador el
mdulo ADC. La mxima salida del sensor es 1,5 voltios, cuando la temperatura es 150 grados
Celsius. Por esto es importante cambiar el valor de referencia positiva del convertidor anlogo
digital, con el fin de mejorar la resolucin de la medida de voltaje. Para el ejemplo de este
captulo se configurar el voltaje de referencia positivo del ADC, en 2,5 voltios. Cambiando la
referencia positiva a 2,5 voltios el convertidor entregar un resultado binario de 1023 cuando el
voltaje a convertir es de 2,5 voltios. Para el caso de este sensor, se ver definido por las siguientes
relaciones:
Vadc
Radc
V
=
5 , 2
1023
Ecuacin 12-1

Donde Radc es el resultado binario de la conversin AD. De est ecuacin se puede deducir que
el voltaje Vadc, ledo por el convertidor AD, es:

1023
) )( 5 , 2 ( Radc V
Vadc = Ecuacin 12-2

Trabajando con la relacin del sensor que es: 10m voltios por cada grado Celsius, se puede
plantear la siguiente ecuacin:

129
C n
Vadc
C
mV
o o
=
1
10
Ecuacin 12-3

Donde n es la temperatura en grados Celsius, que est registrando el sensor, de est ecuacin se
puede deducir que la temperatura n es:

mV
Vadc C
C n
o
o
10
) )( 1 (
= Ecuacin 12-4

Remplazando la ecuacin (12.2), en (12.4), se obtiene la siguiente relacin:

Radc
Radc
C n
o
244 , 0
23 , 10
) )( 5 , 2 (
= = Ecuacin 12-5

Est relacin debe ser implementada en la conversin AD, en el programa del PIC.

Para contextualizar el uso de este sensor se puede observar y analizar el siguiente cdigo fuente
para un PIC 16F877A:

//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;
//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;
void main( void )
{
//Declaracin de variables.
unsigned int Radc, TemI;
float Tem;
char Text[16];
//Configura el mdulo ADC con el pin AN3
//como voltaje de referencia positiva.
ADCON1 = 0b11000001;
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Temperatura:");
130
while(1) //Bucle infinito.
{
//Lectura del canal 0 del ADC.
Radc = ADC_Read(0);
//Uso de la ecuacin (13.5).
Tem = 0.244*Radc;
//Se convierte el resultado a un nmero entero.
TemI = Tem;
//Se convierte el nmero entero a una cadena de caracteres.
IntToStr( TemI, Text );
//Se imprime el resultado.
Lcd_Out( 2, 1, Text);
//Retardo de 100m segundos.
delay_ms(100);
}
}

Terminada la edicin y compilacin del programa se debe construir un circuito en ISIS con los
siguientes dispositivos: 16F877A, RES, LM35, y LM016L, este se puede apreciar en la siguiente
figura:

Circuito 12-1
131
El arreglo de resistencias de 330 permite hacer un divisor de voltaje para crear la referencia de
2,5 voltios. Durante la marcha de la simulacin se puede cambiar el valor de la temperatura en el
sensor LM35, para ver su funcionamiento.
12.2 Sensores de presin
La presin es una variable fsica, representada por un vector que est definido como la fuerza
aplicada en una superficie especfica. La presin se denota en diferentes unidades dependiendo
del sistema, la presin se puede dar en: psi, Pascal, Atmsferas, centmetros de mercurio, etc.
Para los fines prcticos de este captulo se trabajar con el sensor de presin MPX4115, este
sensor est caracterizado en Kilo Pascal, y permite medir presiones entre 15 y 115 KPa, o entre
2,18 y 16,7 psi. La apariencia fsica, la distribucin de pines y la vista en ISIS, de este dispositivo
es la siguiente:

Figura 12-2

Pin Funcin
1 Vout
2 GND, Referencia
3 Vs, Poder
4, 5, 6 No implementado

Tabla 12-1

Independiente del sensor que se implemente, cada uno debe contar con una relacin de salida o
funcin de transferencia, en el caso particular del sensor MPX4115 la funcin de transferencia
especificada por el fabricante es:

) 095 , 0 009 , 0 ( = P s V Vout Ecuacin 12-6

Donde Vout es el voltaje de salida del sensor, P es la presin en Kilo Pascal, y Vs el voltaje de
alimentacin del sensor. Despejando de la ecuacin (13.6), la presin P, se obtiene:


555 , 10
111 , 111
+ =
Vs
Vout
P Ecuacin 12-7

132
En funcin del convertidor AD, del PIC configurado con 10 bits de resolucin se puede concluir
que:
Radc
nV V
=
1023
5
Ecuacin 12-8

Por lo tanto despejando el voltaje n de la ecuacin (12.8) y remplazando en la ecuacin (12.7), se
puede obtener la relacin o ecuacin que se debe usar en el microcontrolador para hacer la lectura
del sensor, est relacin es la siguiente:

555 , 10
54306 , 0
+ =
Vs
Radc
P Ecuacin 12-9

Para el caso particular de este ejemplo se usar una fuente de poder de 5 voltios la cual alimenta
el sensor y el micro, por lo tanto Vs es igual a 5 voltios, y la relacin final queda de la siguiente
forma:
555 , 10 10861 , 0 + = Radc P Ecuacin 12-10

Para demostrar el funcionamiento prctico de este tipo de sensores se puede observar y analizar el
siguiente cdigo fuente:

//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

void main( void )
{
//Declaracin de variables.
unsigned int Radc, PreI;
float Pre;
char Text[16];
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Presion en KPa:");
133
while(1) //Bucle infinito.
{
//Lectura del canal 0 del ADC.
Radc = ADC_Read(0);
//Uso de la ecuacin (13.9).
Pre = 0.10861*Radc+10,5555;
//Se forza el resultado a la parte entera.
PreI = Pre;
//Se convierte el nmero entero a una cadena de caracteres.
IntToStr( PreI, Text );
//Se imprime el resultado.
Lcd_Out( 2, 1, Text);
//Retardo de 100m segundos.
delay_ms(100);
}
}

Terminada la edicin y compilacin del programa se puede implementar en el simulador ISIS los
dispositivos: 16F877A, MPX4115, y LM016L, para realizar la simulacin del sistema, el circuito
debe tener la siguiente apariencia:

Circuito 12-2
134
12.3 Sensores de distancia
Los sensores de distancia permiten medir una longitud desde el punto de ubicacin del sensor
hasta un obstculo puesto en un punto dentro del rango de trabajo del sensor. La implementacin
de este tipo de dispositivos es de utilidad en sistemas de control, y en proyectos de robtica. Para
el caso puntual de este captulo se trabajar con el sensor GP2D12, este dispositivo usa como
estrategia de medida un rayo de luz infrarroja y su reflejo para determinar la longitud. La
apariencia fsica la distribucin de pines y la vista en el simulador ISIS del sensor son los
siguientes:


Figura 12-3

Pin Funcin
1 Vout
2 GND, Referencia
3 Vcc, Poder

Tabla 12-2

Este tipo de sensores cuentan con un comportamiento no lineal, esto quiere decir que la salida no
obedece a una funcin de transferencia lineal. Para comprender de forma clara este concepto se
puede observar y analizar la siguiente grfica que muestra el comportamiento de la salida en
funcin de la distancia:



Figura 12-4
135
Este comportamiento en un sensor es de difcil aplicacin, dado que en algunos casos los
fabricantes no entregan una funcin de transferencia til de tal forma que pueda ser usada en una
sola ecuacin. Sin embargo no es un obstculo para el uso del sensor. Como se puede apreciar en
la hoja tcnica el rango de accin es de 10 a 80 centmetros tal como se puede apreciar en la
grfica. La grfica mostrada est contenida en la hoja tcnica del dispositivo y est es realizada
experimentalmente. Para poder caracterizar el comportamiento del sensor y realizar una funcin
de transferencia es indispensable realizar un proceso matemtico conocido como linealizacin.
Para este fin se hace una interpolacin con una cantidad finita de puntos conocidos de la funcin,
estos puntos se toman de las medidas experimentales. Cuantos ms puntos se evalen ms precisa
ser la funcin de transferencia.

Para iniciar este proceso se escogen 2 puntos, que estn equitativamente distribuidos. Por ejemplo
el punto a 10cm, y 80cm. Para cada uno de los puntos se realiza una ecuacin de orden igual al
nmero de puntos menos uno, en este caso sern ecuaciones de primer orden. Se asume como
variable independiente x los datos de entrada que en este caso son el voltaje de salida del sensor,
como variable dependiente y, la distancia en centmetros. Para comprender este concepto observe
la siguiente ecuacin que representa el comportamiento exponencial del sensor:

B
x
A
y + = Ecuacin 12-11

Recordando que y, representa la distancia y que x, el voltaje de salida del sensor, se usan los datos
de dos puntos y se remplazan en las ecuaciones de la siguiente forma:

Distancia(y) Vo, Salida sensor(x)
10cm 2,35V
80cm 0,41V

Tabla 12-3
Sistema de ecuaciones:

B
A
B
A
+ =
+ =
41 , 0
80
35 , 2
10
Ecuacin 12-12

Sistema de ecuaciones con dos incgnitas:

B A
B A
+ =
+ =
43902 , 2 80
425531 , 0 10
Ecuacin 12-13

Solucionando el sistema de ecuaciones se puede determinar que las constantes son:

A=34,76546392
B=-4,793814433

De est forma se puede formalizar la funcin de transferencia del sensor con la ecuacin:
136
793814433 , 4
76546392 , 34
+ =
x
y Ecuacin 12-14

Como la variable x representa el voltaje de salida del sensor y teniendo presente que el valor del
sensor no supera 2,5 voltios, la referencia del convertidor AD, se puede ajustar a 2,5 voltios. Para
estblecer la conversin se puede usar la ecuacin: (12.15)

1023
5 , 2 Radc
Vadc = Ecuacin 12-15

Remplazando la ecuacin (12.15) en la ecuacin (12.14), obtenemos la siguiente relacin o
funcin de transferencia:

793814433 , 4
02784 , 14226
=
Radc
y Ecuacin 12-16

El paso siguiente es implementar un cdigo fuente que use la funcin de transferencia y que
posteriormente visualice el valor capturado, para este fin se puede observar y analizar el siguiente
cdigo fuente:

//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

void main( void )
{
//Declaracin de variables.
unsigned int Radc, DisI;
float Dis;
char Text[16];
//Configura el mdulo ADC con el pin AN3
//como voltaje de referencia positiva.
ADCON1 = 0b11000001;
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
137
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Distancia:");

while(1) //Bucle infinito.
{
//Lectura del canal anlogo.
Radc=ADC_Read(0);
//Implementacin de la funcin de transferencia (13.15).
Dis = (14226.02784/Radc)-4.793814433;
//Se para el resultado a un valor entero.
DisI=Dis;
//Se convierte el valor entero en cadena de texto.
IntToStr( DisI, Text );
//Se imprime la lectura del sensor.
Lcd_Out( 2, 1, Text );
//Retardo de 100m segundos.
delay_ms(100);
}
}

Por ltimo para verificar el comportamiento del sistema se implementa en ISIS, los dispositivos:
16F877A, RES, LM016L, y el sensor GP2D12, en el siguiente circuito:


Circuito 12-3
138
12.4 Sensores LDR
Los sensores LDR, son dispositivos que cambian su resistencia en funcin de la intensidad de luz,
cuanto mayor sea la intensidad de la luz, menor es la resistencia que ofrece la LDR. Estos
dispositivos son tiles para determinar, la presencia o ausencia de luz en el ambiente, es posible
concebir con estos dispositivos controles de luminosidad. La apariencia fsica y las vistas
posibles en el simulador ISIS, son las siguientes:

Figura 12-5

Las caractersticas elctricas de estos dispositivos no son fcil de conseguir dado su simple
funcionamiento y gran variedad de fabricantes, las LDR, o fotoresistencias, se adquieren
comercialmente en tamaos diversos, esto implica que el rango de resistencia cambia en funcin
del tamao, una LDR, de tamao grande tiene rangos de cambio menor que una LDR pequea.
Incluso los cambios de resistencia no son exactamente iguales en dos LDR, del mismo tamao.
Ests razones hacen que la forma de mayor simplicidad para su uso sea la lectura de su
resistencia, o el voltaje que se desempea en sus terminales. Para usar una LDR, la forma ms
simple es realizar un divisor de voltaje con una resistencia fija, para entender este concepto se
puede observar el siguiente arreglo o circuito:


Circuito 12-4

Asumiendo la teora bsica de circuitos elctricos para un divisor de voltaje se puede
implementar la siguiente ecuacin:

R LDR
Vcc LDR
Vadc
+
=
) (
Ecuacin 12-17

139
Despejando de la ecuacin (12.17), el valor de la foto resistencia, LDR se obtiene la siguiente
ecuacin:
Vout Vcc
R Vout
LDR

=
) )( (
Ecuacin 12-18

Dado que el valor de salida Vout se puede ingresar a una entrada AD, del microcontrolador se
puede asumir como Vadc, con la siguiente relacin y un voltaje de referencia positivo de 5
voltios:
004887585 , 0 ) (
1023
) 5 )( (
Radc
Radc
Vadc = = Ecuacin 12-19

Remplazando la ecuacin (13.19) en la ecuacin (13.18), y asumiendo que Vcc es de 5 voltios,
obtenemos la siguiente relacin:

) 004887585 , 0 )( ( 5
) )( 04887585 , 0 )( (
Radc
R Radc
LDR

= Ecuacin 12-20

Para el caso particular de la simulacin de este ejercicio la resistencia del divisor de voltaje ser
de 10k de est manera la ecuacin para calcular la resistencia de la LDR, es:

) 004887585 , 0 )( ( 5
) 87585 , 48 )( (
Radc
Radc
LDR

= Ecuacin 12-21

Para la compilacin y edicin del programa se puede observar y analizar el siguiente cdigo
fuente:

//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;
//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;

void main( void )
{
//Declaracin de variables.
unsigned long Radc, DisI;
char Text[16];
//Inicio del LCD.
140
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Resistencia:");
while(1) //Bucle infinito.
{
//Lectura del canal anlogo.
Radc=ADC_Read(0);
//Implementacin del clculo de la LDR, ecuacin (13.20).
DisI = (Radc*48.87585533)/(5.0-Radc*0.004887585);
//Se convierte el valor entero largo, en cadena de texto.
LongToStr( DisI, Text );
//Se imprime la lectura del sensor.
Lcd_Out( 2, 1, Text );
//Retardo de 100m segundos.
delay_ms(100);
}
}

Para realizar la simulacin en ISIS, se implementan los siguiente dispositivos: 16F877A, RES,
LM016L, TORCH_LDR, en el siguiente circuito electrnico:


Circuito 12-5
141
12.5 Sensores de humedad y temperatura
La humedad y la temperatura son dos variables fsicas de amplio uso en la industria y para su
medida se pueden usar dispositivos que integran las dos lecturas simultneamente, en un solo
encapsulado. La familia de sensores SHT7x permiten hacer la lectura de ambos parmetros, con
una calibracin de fbrica que garantiza la fidelidad de las lecturas. La apariencia fsica y la vista
de estos dispositivos en ISIS, as como su distribucin de pines, es la siguiente:


Figura 12-6

Pin Funcin
1 Reloj
2 Vdd, Poder
3 Gnd, Referencia
4 Datos

Tabla 12-4

Estos sensores entregan la informacin por medio de un puerto serial similar al protocolo IC, sin
embargo no es exactamente igual, y por est razn no es posible usarlo. Esto implica realizar por
medio del cdigo de programa, el protocolo de comunicacin especificado en la hoja tcnica del
dispositivo. El protocolo incluye una condicin de inicio, bloque de datos tanto de lectura como
de escritura, y un bit de conformacin o ACK. La comunicacin se basa en dos pines uno de reloj
que siempre debe ser de salida y un pin de datos bidireccional, el cual es de drenador abierto, lo
que hace necesario implementar una resistencia pull-up en est lnea a Vcc de 10k.

Para realizar la comunicacin con el sensor, el desarrollador debe implementar su propia librera
para el enlace de datos, a continuacin se mostrar paso a paso un ejemplo que permite cumplir
con este cometido:

//Declaracin de pines de comunicacin.
sbit SHT_Reloj at RC0_bit;
sbit SHT_Datos at RC1_bit;

//Declaracin de TRIS de los pines de comunicacin.
sbit SHT_Reloj_Dire at TRISC0_bit;
sbit SHT_Datos_Dire at TRISC1_bit;

//Declaracin de constantes.
const unsigned short RH_8bits_TEM_12bits = 1;
142
const unsigned short RH_12bits_TEM_14bits = 0;
const unsigned short Peso_bits[8] = {1,2,4,8,16,32,64,128};

//Bandera de resolucin.
unsigned short RH_TEM;

//Funcin para estblecer un estdo
//lgico en el pin de datos
void SHT_Bus( unsigned short e )
{
//Si el estdo es 1 se impone en alta
//impedancia el pin de datos.
if( e )
SHT_Datos_Dire = 1;
else
{
//Si el estdo es un 0 lgico
//se estblece la salida en 0.
SHT_Datos_Dire = 0;
SHT_Datos = 0;
}
}

//Funcin para estblecer el estdo del reloj.
void SHT_Reloj_Salida( unsigned short e )
{
//Se estblece el estdo lgico en el reloj.
if( e )
SHT_Reloj = 1;
else
SHT_Reloj = 0;
//Periodo del reloj, para frecuencia de 1MHz.
delay_us(1);
}

//Funcin para crear la condicin de inicio.
void SHT_Inicio( void )
{
//Secuencia de inicio.
SHT_Reloj_Salida(1);
SHT_Bus(0);
SHT_Reloj_Salida(0);
SHT_Reloj_Salida(1);
SHT_Bus(1);
SHT_Reloj_Salida(0);
delay_ms(1);
}


143
//Funcin para escribir un dato en el bus.
void SHT_Escribe_Bus( unsigned short d )
{
unsigned short n;
//Bucle para el envi serial.
for( n=7; n!=255; n-- )
{
//Se asigna el bit segn su peso.
if( (d>>n)&1 )
SHT_Bus( 1 );
else
SHT_Bus( 0 );
//Generacin de pulsos de reloj.
SHT_Reloj_Salida( 1 );
SHT_Reloj_Salida( 0 );
}
//Generacin de bit ACK.
SHT_Bus( 1 );
SHT_Reloj_Salida( 1 );
SHT_Reloj_Salida( 0 );
}

//Funcin para leer un dato en el bus.
unsigned short SHT_Leer_Bus( void )
{
unsigned short n, Dato_SHT=0;
//Se configura el bus de entrada.
SHT_Bus( 1 );
//Bucle para recibir los bits de forma serial.
for( n=7; n!=255; n-- )
{
//Pulso de reloj.
SHT_Reloj_Salida( 1 );
//Se reciben los bits segn su peso.
if( SHT_Datos )
Dato_SHT += Peso_bits[n];
SHT_Reloj_Salida( 0 );
}
//Se transmite la condicin de ACK.
SHT_Bus( 0 );
SHT_Reloj_Salida( 1 );
SHT_Reloj_Salida( 0 );
//Se deja el bus de entrada.
SHT_Bus( 1 );
//Se retorna el valor de la lectura.
return Dato_SHT;
}

//Funcin para grabar el registro Status.
144
void SHT_Status_Graba( unsigned short s )
{
//Se transmite el valor del status.
SHT_Inicio();
SHT_Escribe_Bus( 0b00000110 );
SHT_Escribe_Bus( s );
}

//Funcin para leer el valor del Status.
unsigned short SHT_Status_Leer( void )
{
unsigned short st;
SHT_Inicio();
SHT_Escribe_Bus( 0b00000111 );
st=SHT_Leer_Bus();
SHT_Leer_Bus();
return st;
}

//Funcin para leer la temperatura.
float SHT_Leer_Tem( void )
{
float tem;
unsigned int LEC=0;
unsigned short DH, DL;
//Se aplica el protocolo de lectura.
SHT_Inicio();
SHT_Escribe_Bus( 0b00000011 );
//Espera para hacer la lectura.
delay_ms(310);
DH=SHT_Leer_Bus();
DL=SHT_Leer_Bus();
SHT_Leer_Bus();
LEC = DL + DH*256;
//Se implementan las ecuaciones para
//la temperatura.
if( RH_TEM )
tem = -40.1 + 0.04*LEC;
else
tem = -40.1 + 0.01*LEC;
//Se retorna la temperatura.
return tem;
}

float SHT_Leer_Hum( void )
{
float hum;
unsigned int LEC=0;
unsigned short DH, DL;
145
//Se aplica el protocolo de lectura.
SHT_Inicio();
SHT_Escribe_Bus( 0b00000101 );
//Espera para hacer la lectura.
delay_ms(310);
DH=SHT_Leer_Bus();
DL=SHT_Leer_Bus();
SHT_Leer_Bus();
LEC = DL + DH*256;
//Se implemetan las ecuacion para
//la humedad.
if( RH_TEM )
hum = -4.3468 + 0.5872*LEC - 0.00040845*LEC*LEC;
else
hum = -4.3468 + 0.0367*LEC - 0.0000015955*LEC*LEC;
//Se retorna la humedad.
return hum;
}

//Funcin para inicializar el sensor.
void Inicio_SHT7x( unsigned short St )
{
unsigned short n;
//Configuracin de pines,
//y estdo inicial del bus de datos.
SHT_Reloj_Dire = 0;
//Se estble el pin de datos en 1.
SHT_Bus(1);
//Se inicia el reloj en 0.
SHT_Reloj_Salida(0);
delay_ms(100);
//Se generan 9 ciclos de reloj, para reiniciar el sensor.
for(n=0; n<9; n++)
{
SHT_Reloj_Salida(1);
SHT_Reloj_Salida(0);
}
//Se configura el registro Status.
SHT_Inicio();
SHT_Status_Graba( St );
delay_ms(1);
RH_TEM = St;
}

Para el caso puntual de este ejemplo se complementa el cdigo con la siguiente funcin main:

void main( void )
{
//Declaracin de variables.
146
float Sen;
char Text[16];
//Inicio del LCD.
Lcd_Init();
//Se inicializa el sensor SHT7x.
Inicio_SHT7x(RH_12bits_TEM_14bits);
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Tem:");
Lcd_Out( 2, 1, "Hum:");
while(1) //Bucle infinito.
{
//Se lee la temperatura y se imprime en el LCD.
Sen = SHT_Leer_Tem();
FloatToStr( Sen, Text );
Lcd_Out( 1, 6, Text );
//Se lee la humedad y se imprime en el LCD.
Sen = SHT_Leer_hum();
FloatToStr( Sen, Text );
Lcd_Out( 2, 6, Text );
}
}

Finalizada la edicin y compilacin del cdigo fuente, se procede a realizar la simulacin en
ISIS, con los dispositivos: 16F877A, LM016L, RES, y SHT71, en el siguiente circuito
electrnico:

Circuito 12-6
147
13 Comunicacin con
dispositivos
La comunicacin con diversos dispositivos se hace indispensable para realizar tareas como la
lectura de sensores, el sistema de control, y lectura de mdulos como: relojes en tiempo real,
GPS, puntos inalmbricos, entre otros. En funcin de la necesidad y de las capacidades del
desarrollador, tambin es posible crear sus propios aplicativos de software para ordenadores
personales, ests aplicaciones se pueden desarrollar en paquetes, como Visual Basic, Java, C++,
etc. Para poder simular la conectividad con aplicativos propios e incluso con paquetes de
software como Hyper Terminal, se puede recurrir a aplicativos que crean en el ordenador puertos
seriales virtuales. De la misma forma el simulador ISIS permite implementar un puerto virtual
con conectividad a los puertos seriales fsicos del ordenador. Uno de los aplicativos que permite
crear los puertos virtuales es Virtual Serial Port Kit, del cual se puede descargar una versin
demostrativa en la pgina www.virtual-serial-port.com La apariencia visual de este paquete es la
siguiente:

Figura 13-1

Sin embargo este es tan solo uno de los diversos aplicativos que cumplen con la misma funcin.
13.1 Mdulos GPS
Los mdulos GPS son dispositivos de comunicacin inalmbrica que toman tramas de
informacin suministrada por los satlites artificiales geoestcionarios del planeta. Los mdulos
GPS deben contar con la lectura de un mnimo de tres satlites para realizar un clculo conocido
como triangulacin; este consiste en medir la diferencia en tiempo entre las lecturas para
determinar la posicin del GPS sobre la superficie de la tierra. La calidad de la lectura depender
del nmero de satlites simultneos conectados al GPS; la lectura ser de mayor precisin
cuantos ms satlites estn conectados; sin embargo los GPS comerciales que se consiguen tienen
un margen de error aproximado de 3 metros, lo que implica que con respecto al dimetro del
globo terrqueo, el margen de error es casi del 0%. Los mdulos GPS se pueden adquirir
148
comercialmente en varias presentaciones con encapsulado, o simplemente un circuito impreso
con el mdulo. La apariencia fsica de ellos se puede apreciar en las siguientes figuras:


Figura 13-2

Los mdulos GPS cuentan con puertos seriales que transmiten peridicamente la lectura de las
coordenadas geogrficas ledas por el GPS. El periodo por defecto de los GPS, es un segundo. La
lectura de un GPS, es el conjunto de coordenadas esfricas sobre el globo terrqueo, usando
como referencia de medida el meridiano de Greenwich, y el paralelo del Ecuador. Para
contextualizar este concepto se puede observar el siguiente grfico:



Figura 13-3

Longitud ngulo , Latitud ngulo .

Las coordenadas esfricas usan tres parmetros; el primero es la longitud, que es el ngulo ,
representado en la grfica y se mide a partir del meridiano de Greenwich, este ngulo puede ser
Este, u Oeste, y su magnitud puede variar de 0 a 90 grados. El segundo parmetro es la latitud,
que es el ngulo , representado en la grfica, su punto de referencia es el paralelo del Ecuador y
puede ser Norte, o Sur, de la misma forma su magnitud varia de 0 a 90 grados. El ltimo
parmetro es conocido como altitud, este determina la altura del punto coordenado con respecto
al nivel del mar, y su magnitud est definida en metros.

Los Mdulos GPS, suministran una variedad de datos a dems de las coordenadas esfricas,
como: Nmero de satlites detectados, especificaciones mnimas del GPS, y caractersticas de
curso y velocidad, entre otras. Sin embargo para realizar la lectura de las coordenadas solo se
149
requiere la trama de informacin con el encabezado: $GPGGA. El siguiente ejemplo muestra la
lectura de las coordenadas:
Latitud: 30 47 43,47 Sur.
Longitud: 39 57 33,36 Oeste.
Altura: 2600 metros.

$GPGGA,000000.000,3047.724500,S,03957.556000,W,1,8,0,2600,M,0,M,,*7B

Informacin de Latitud:
$GPGGA,000000.000,3047.724500,S,03957.556000,W,1,8,0,2600,M,0,M,,*7B
Donde 3047.724500,S representa: 30 47 43,47 Sur. Es decir 30 grados, 47.7245 minutos, que
es equivalente a 47 minutos y 43,47 segundos.

Informacin de Longitud:
$GPGGA,000000.000,3047.724500,S,03957.556000,W,1,8,0,2600,M,0,M,,*7B
Donde: 03957.556000,W representa: 39 57 33,36 Oeste. Es decir 39 grados, 57.556 minutos,
que es equivalente a 57 minutos y 33,36 segundos.

Informacin del nmero de satlites, conectados:
$GPGGA,000000.000,3047.724500,S,03957.556000,W,1,8,0,2600,M,0,M,,*7B
Donde este campo 8, representa el nmero de satlites conectados al GPS, en este caso 8.

Informacin de altitud:
$GPGGA,000000.000,3047.724500,S,03957.556000,W,1,8,0,2600,M,0,M,,*7B
Donde 2600,M representa la magnitud en metros y la altitud de 2600 metros.

Los campos de informacin siempre son fijos y ests separados por una coma (,) entre si.

El siguiente ejemplo muestra una trama completa de datos entregados por un GPS:

$GPZDA,000000.000,30,12,1899,00,00*5F
$GPGGA,000000.000,3354.673167,S,04125.539667,W,1,8,0,2600,M,0,M,,*78
$GPGLL,3354.673167,S,04125.539667,W,000000.000,A,A*5F
$GPVTG,9,T,0,M,4.86,N,9.00500277932185,K,A*2A
$GPRMC,000000.000,A,3354.673167,S,04125.539667,W,4.86,9,301299,0,E,A*30
$GPGSA,A,3,1,2,3,4,5,6,17,22,,,,,0,0,0*2D
$GPGSV,2,1,8,1,0,24,0,2,0,24,0,3,0,24,0,4,0,24,0*46
$GPGSV,2,2,8,5,0,24,0,6,0,24,0,17,0,24,0,22,0,24,0*44
$GPRTE,1,1,C,0,*0B

Las tramas de informacin entregadas por un GPS, son de forma texto, por medio de caracteres
ASCII, y finalizadas con los caracteres ASCII, enter: 13, y retroceso del carro 10.

Para fines de diseo es importante identificar la velocidad de transmisin del mdulo GPS y
ajustar la misma velocidad en el mdulo USART del PIC.

Para iniciar el proceso de diseo con el microcontrolador es importante crear una rutina que
identifique las tramas y los encabezados para poder filtrar los datos de inters, que para este caso
son las coordenadas esfricas o geogrficas. Es indispensable usar el mdulo USART del PIC, en
150
este caso, y se establecer una velocidad de transmisin de 4800 bits por segundo. Para evitar la
prdida de datos se implementar la lectura de los datos seriales por medio de las interrupciones.
En primera instancia se hace un programa para el PIC 18F452, que este en capacidad de recibir y
almacenar las tramas en un bfer de datos:

char Dato;
char Bufer[50];
unsigned short Pos=0, Bandera=0;

//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
//Se evala si la interrupcin disparada por
//recepcin serial.
if( PIR1.F5 )
{
//Se lee el dato de entrada.
Dato = UART1_Read();
switch( Dato )
{
case 13: Pos=0; //Se recibe el carcter Enter.
Bandera = 1;
break;
case 10:break; //Se recibe el retroceso del carro.
default:Bufer[Pos++]=Dato; //Se guardan los datos en el bfer.
Bufer[Pos]=0; //Se estblece el fin de cadena.
break;
}

}
}

void main( void )
{
//Se configuran los puertos.
//
//Se activa la interrupcin por
//recepcin serial.
PIE1 = 0b00100000;
//Se desactivan las dems fuentes de interrupcin.
PIE2 = 0;
//Se apagan las banderas de interrupcin.
PIR2 = 0;
PIR1 = 0;
//Configuracin del puerto serial a 4800 bps.
UART1_Init(4800);
//Se activan las interrupciones globales,
//y perifricas.
INTCON = 0b11000000;
151
while(1) //Bucle infinito.
{
//Se evala si una trama ha llegado.
if( Bandera )
{
//Aqu se debe analizar el contenido de la informacin del bfer.
Bandera=0; //Se apaga la bandera de llegada.
}
}
}

El procedimiento siguiente es implementar una funcin que identifique la trama de informacin y
los datos contenidos en ella, es importante recordar que los campos de informacin son fijos pero
no necesariamente el contenido de cada campo. Para estblecer la informacin de la lectura se
usa una variable o estructura diseada por el desarrollador:

typedef struct
{
short Grados_longitud;
float Minutos_longitud;
char Longitud;
short Grados_latitud;
float Minutos_latitud;
char Latitud;
float Altitud;
short Satelites;
}Coordenada;

A continuacin se mostrar una funcin capaz de validar una trama para la lectura de las
coordenadas:

//Funcin para detectar la trama de coordenadas.
short EsGPGGA( char *trama )
{
//Est funcin retorna 1 si la trama es vlida y 0 de lo contrario.
if( trama[0]=='$' && trama[1]=='G' && trama[2]=='P'
&& trama[3]=='G' && trama[4]=='G' && trama[5]=='A' )
return 1;
else
return 0;
}

A continuacin se muestra un ejemplo de una funcin diseada para leer los datos de las
coordenadas:

//Funcin para adquirir los datos del campo.
Coordenada LecturaGPS( char *trama )
{
//Declaracin de variables.
152
Coordenada C;
char Texto[50];
unsigned short j,k;
//Valor inicial de las variables.
C.Grados_longitud=0;
C.Minutos_longitud=0;
C.Longitud=0;
C.Grados_latitud=0;
C.Minutos_latitud=0;
C.Latitud=0;
C.Altitud=0;
C.Satelites=0;

//Se verifica que el encabezado contenga el texto $GPGGA.
if( !EsGPGGA( trama ) )return C;
//Se filtra el campo 9 que contiene la altitud.
BuscarCampo( Trama, Texto, 9 );
//Se convierte el texto en el valor numrico.
C.Altitud = atof(Texto);
//Se filtra el campo 7 que contiene el nmero de satlites detectados.
BuscarCampo( Trama, Texto, 7 );
//Se convierte el texto en el valor numrico.
C.Satelites = atoi(Texto);
//Se filtra el campo 2 que contiene los minutos de la latitud.
BuscarCampo( Trama, Texto, 2 );
//Se convierte el texto en el valor numrico.
C.Minutos_latitud = atof( Texto + 2 );
//Se truncan los minutos de la latitud.
Texto[2]=0;
//Se convierte el texto en el valor numrico de los grados de la latitud.
C.Grados_latitud = atoi(Texto);
//Se filtra el campo 3 que contiene la orientacin de la latitud.
BuscarCampo( Trama, Texto, 3 );
C.Latitud = Texto[0];
//Se filtra el campo 4 que contiene los minutos de la longitud.
BuscarCampo( Trama, Texto, 4 );
//Se convierte el texto en el valor numrico los minutos de la longitud.
C.Minutos_longitud = atof( Texto + 3 );
Texto[3]=0;
//Se convierte el texto en el valor numrico de los grados de la longitud.
C.Grados_longitud = atoi( Texto );
//Se filtra el campo 2 que contiene.
BuscarCampo( Trama, Texto, 5 );
C.Longitud = Texto[0];
return C;
}

La siguiente funcin permite buscar dentro de la trama enviada por el GPS, un campo de
informacin determinado:
153

//Funcin para buscar y filtrar un campo en la trama.
void BuscarCampo( char *Fuente, char *Destino, short campo )
{
unsigned short j=0,k=0;
//Bucle para buscar el campo.
while( j<campo )if( Fuente[k++]==',' )j++;
j=0;
//Bucle para copiar el campo.
while( !(Fuente[k]==',' || Fuente[k]=='*') )
{
Destino[j++]=Fuente[k++];
Destino[j]=0;
}
}

Est ltima funcin permite convertir la informacin de una lectura en una cadena de
coordenadas entendible en grados, minutos, segundos, y orientacin:

//Funcin para encadenar los valores de una coordenada.
void Convertir_coordenada( char *coor, int grados, float minutos, char ll )
{
//Declaracin de variables de la funcin.
char Text[20];
short j=0,k=0;
short g;
float s;

//Se pega en la cadena de texto, el valor de los grados.
IntToStr( grados, Text );
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
coor[k++]=':';
//Se separan los segundos de los minutos.
g = (short)minutos;
s = minutos - (float)g;
//Se pega en la cadena de texto, el valor de los minutos.
IntToStr( g, Text );
j=0;
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
154
coor[k++]=':';
//Se calculan los segundos, de la fraccin de minutos.
s *= 60.0;
//Se pega en la cadena de texto, el valor de los segundos.
FloatToStr( s, Text );
j=0;
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
//Se pega en la cadena de texto, la orientacin.
coor[k++]=' '; coor[k++]=ll; coor[k]=0;
}

Complementando las funciones antes citadas y la estructura final del programa con un display
LCD de caracteres y la comunicacin del puerto serial se tiene el siguiente cdigo fuente final:

// Definicin de las conexiones del LCD.
sbit LCD_RS at RD4_bit;
sbit LCD_EN at RD5_bit;
sbit LCD_D4 at RD0_bit;
sbit LCD_D5 at RD1_bit;
sbit LCD_D6 at RD2_bit;
sbit LCD_D7 at RD3_bit;

//Definicin de los registros TRIS del LCD.
sbit LCD_RS_Direction at TRISD4_bit;
sbit LCD_EN_Direction at TRISD5_bit;
sbit LCD_D4_Direction at TRISD0_bit;
sbit LCD_D5_Direction at TRISD1_bit;
sbit LCD_D6_Direction at TRISD2_bit;
sbit LCD_D7_Direction at TRISD3_bit;

//Estructura para la lectura de una coordenada esfrica.
typedef struct
{
short Grados_longitud;
float Minutos_longitud;
char Longitud;
short Grados_latitud;
float Minutos_latitud;
char Latitud;
float Altitud;
short Satelites;
}Coordenada;

//Declaracin de variables.
155
char Dato;
char Bufer[100];
unsigned short Pos=0;
unsigned short Bandera=0;
//Funcin para detectar la trama de coordenadas.
short EsGPGGA( char *trama )
{
//Est funcin retorna 1 si la trama es valida y 0 de lo contrario.
if( trama[0]=='$' && trama[1]=='G' && trama[2]=='P'
&& trama[3]=='G' && trama[4]=='G' && trama[5]=='A' )
return 1;
else
return 0;
}

//Funcin para buscar y filtrar un campo en la trama.
void BuscarCampo( char *Fuente, char *Destino, short campo )
{
unsigned short j=0,k=0;
//Bucle para buscar el campo.
while( j<campo )if( Fuente[k++]==',' )j++;
j=0;
//Bucle para copiar el campo.
while( !(Fuente[k]==',' || Fuente[k]=='*') )
{
Destino[j++]=Fuente[k++];
Destino[j]=0;
}
}

//Funcin para adquirir los datos del campo.
Coordenada LecturaGPS( char *trama )
{
//Declaracin de variables.
Coordenada C;
char Texto[50];
unsigned short j,k;
//Valor inicial de las variables.
C.Grados_longitud=0;
C.Minutos_longitud=0;
C.Longitud=0;
C.Grados_latitud=0;
C.Minutos_latitud=0;
C.Latitud=0;
C.Altitud=0;
C.Satelites=0;

//Se verifica que el encabezado contenga el texto $GPGGA.
if( !EsGPGGA( trama ) )return C;
156
//Se filtra el campo 9 que contiene la altitud.
BuscarCampo( trama, Texto, 9 );
//Se convierte el texto en el valor numrico.
C.Altitud = atof(Texto);
//Se filtra el campo 7 que contiene el nmero de satlites detectados.
BuscarCampo( trama, Texto, 7 );
//Se convierte el texto en el valor numrico.
C.Satelites = atoi(Texto);
//Se filtra el campo 2 que contiene los minutos de la latitud.
BuscarCampo( trama, Texto, 2 );
//Se convierte el texto en el valor numrico.
C.Minutos_latitud = atof( Texto + 2 );
//Se truncan los minutos de la latitud.
Texto[2]=0;
//Se convierte el texto en el valor numrico de los grados de la latitud.
C.Grados_latitud = atoi(Texto);
//Se filtra el campo 3 que contiene la orientacin de la latitud.
BuscarCampo( trama, Texto, 3 );
C.Latitud = Texto[0];
//Se filtra el campo 4 que contiene los minutos de la longitud.
BuscarCampo( trama, Texto, 4 );
//Se convierte el texto en el valor numrico los minutos de la longitud.
C.Minutos_longitud = atof( Texto + 3 );
Texto[3]=0;
//Se convierte el texto en el valor numrico de los grados de la longitud.
C.Grados_longitud = atoi( Texto );
//Se filtra el campo 2 que contiene.
BuscarCampo( trama, Texto, 5 );
C.Longitud = Texto[0];
return C;
}

//Funcin para encadenar los valores de una coordenada.
void Convertir_coordenada( char *coor, int grados, float minutos, char ll )
{
//Declaracin de variables de la funcin.
char Text[20];
short j=0,k=0;
short g;
float s;

//Se pega en la cadena de texto, el valor de los grados.
IntToStr( grados, Text );
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
157
coor[k++]=':';
//Se separan los segundos de los minutos.
g = (short)minutos;
s = minutos - (float)g;
//Se pega en la cadena de texto, el valor de los minutos.
IntToStr( g, Text );
j=0;
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
coor[k++]=':';
//Se calculan los segundos, de la fraccin de minutos.
s *= 60.0;
//Se pega en la cadena de texto, el valor de los segundos.
FloatToStr( s, Text );
j=0;
while( Text[j]!=0 )
{
if( Text[j]!=' ' )
coor[k++]=Text[j];
j++;
}
//Se pega en la cadena de texto, la orientacin.
coor[k++]=' '; coor[k++]=ll; coor[k]=0;
}

//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
//Se evala si la interrupcin disparada por
//recepcin serial.
if( PIR1.F5 )
{
//Se lee el dato de entrada.
Dato = UART1_Read();
switch( Dato )
{
case 13: Pos=0; //Se recibe el carcter Enter.
Bandera = 1;
break;
case 10:break; //Se recibe el retroceso del carro.
default:Bufer[Pos++]=Dato; //Se guardan los datos en el bfer.
Bufer[Pos]=0; //Se estblece el fin de cadena.
break;
}
}
158
}

void main( void )
{
Coordenada C;
char Texto[20];
//Se configuran los puertos.
TRISB = 0;
PORTB = 0;
//Se activa la interrupcin por
//recepcin serial.
PIE1 = 0b00100000;
//Se desactivan las dems fuentes de interrupcin.
PIE2 = 0;
//Se apagan las banderas de interrupcin.
PIR2 = 0;
PIR1 = 0;
//Configuracin del puerto serial a 4800 bps.
UART1_Init(4800);
//Se activan las interrupciones globales,
//y perifricas.
INTCON = 0b11000000;
//Inicializacin del display LCD.
Lcd_Init();
Lcd_Cmd(_LCD_CURSOR_OFF);
while(1) //Bucle infinito.
{
//Se evala si una trama ha llegado.
if( Bandera )
{
//Se verifica que la trama sea valida para las coordenadas.
if( EsGPGGA( Bufer ) )
{
//Se leen los datos de las coordenadas y se guardan en la variable C.
C=LecturaGPS( Bufer );
//Se transcriben los datos de la latitud.
Convertir_coordenada( Texto, C.Grados_latitud, C.Minutos_latitud, C.Latitud );
//Se imprimen los datos de la latitud en el display LCD.
Lcd_Out(1,1,"Lat ");
Lcd_Out(1,5,Texto);
//Se transcriben los datos de la longitud.
Convertir_coordenada(Texto,C.Grados_longitud,C.Minutos_longitud,C.Longitud);
//Se imprimen los datos de la longitud en el display LCD.
Lcd_Out(2,1,"Lon ");
Lcd_Out(2,5,Texto);
//Se transcriben el valor de la altitud.
FloatToStr(C.Altitud,Texto);
//Se imprimen el valor de la altitud en el display LCD.
Lcd_Out(3,1,"Altitud: ");
159
Lcd_Out(3,9,Texto);
//Se transcriben el valor del nmero de satlites conectados.
IntToStr(C.Satelites,Texto);
//Se imprimen el nmero de satlites en el display LCD.
Lcd_Out(4,1,"Satelites: ");
Lcd_Out(4,11,Texto);
}
Bandera=0; //Se apaga la bandera de llegada.
}
}
}

Despus de editar y compilar el programa con fuente de reloj de 20 Mhz, se procede a crear en
ISIS, un circuito con los siguientes dispositivos: PIC 18F452, LM044L, y el puerto virtual,
COMPIM. Este ltimo se debe configurar a 4800 bps, tanto en el puerto virtual como el puerto
real, la vista de configuracin del puerto virtual COMPIM debe ser la siguiente:

Figura 13-4

La configuracin del puerto fsico que en este caso est determinado como COM1, puede variar
en funcin de los puertos disponibles en el ordenador.
160
La construccin del circuito en ISIS debe ser como se aprecia en la siguiente grfica:

Circuito 13-1

La conexin del GPS, en este caso se puede hacer por medio de un simulador de GPS, o por
medio de un GPS real conectado al puerto fsico. Para la simulacin del GPS, se puede usar el
paquete de software: Virtual GPS, o cualquier otro que funcione de la misma forma, la vista del
simulador de GPS, es la siguiente:

Figura 13-5
161
En este caso se pueden comparar los datos emitidos por el simulador y su verificacin en el
circuito hecho en ISIS. De la misma forma se pueden cambiar los datos enviados por el simulador
de GPS. Se debe recordar hacer la creacin de dos puertos virtuales cruzados, si se desea hacer la
simulacin de todo el sistema con un simulador de GPS.
13.2 Mdulos inalmbricos unidireccionales
Las comunicaciones inalmbricas entre dos puntos hacen parte fundamental de muchas
aplicaciones en el mbito del control y el monitoreo de variables o estdos. La lectura de un
sensor, o el control de actuadores son posibles por medio de enlaces inalmbricos. La
comunicacin usada por estos dispositivos es unidireccional o simplex. Los mdulos
inalmbricos tiles para este fin funcionan con modulacin ASK, o FSK, y tienen velocidades de
transmisin hasta 9600 bits por segundo. Este tipo de dispositivos se pueden conseguir de
fabricantes como Laipac Tech, o Linx Technologies, entre otros. La apariencia fsica de estos
dispositivos es la siguiente:


Figura 13-6

Estos dispositivos solo son un medio de transmisin inalmbrico por lo cual no tienen ningn
sistema de correccin ni deteccin de errores de transmisin, por est razn es importante hacer
dentro de la programacin alguna rutina de deteccin de errores. Para fines de este ejemplo se
implementarn los radios Laipac. De igual manera las frecuencias portadoras de estos
dispositivos son variadas, y funcionan dentro del espectro de bandas libres para enlaces de
comunicacin. La distribucin de pines de estos dispositivos es la siguiente:




Figura 13-7


162
TLP434A
PIN Funcin
1 GND, Referencia
2 Entrada serial
3 Vcc, de 5 a 12 V
4 Antena
RLP434A
PIN Funcin
1 GND, Referencia
2 Salida Serial
3 Salida de prueba
4 Vcc
5 Vcc 5 V
6 GND, Referencia
7 GND, Referencia
8 Antena

Tabla 13-1

Para el envi de bits este ejemplo usa la modulacin por ancho de pulso o PWM. El programa
representa un 1 lgico con un pulso en alto de 2m segundos de duracin seguido por 1m segundo
en bajo, el 0 lgico se transmite con un pulso en alto de 1m segundo y 1m segundo en bajo, y
como estrategia de sincronismo se implementa un pulso en alto de 500u segundos, y 500u
segundos en bajo. Para este ejemplo se envan 16 pulsos de sincronismo, posteriormente se
envan 8 bits con el byte que se desea transmitir, y por ltimo se transmiten 4 bits con un nmero
de 0 a 8 que contiene el nmero de unos que contiene el byte que se est transmitiendo como
estrategia de verificacin. Este sistema no est en capacidad de corregir errores de transmisin,
pero si permite verificar el dato recibido, en otras palabras el sistema entrega un dato que es
recibido correctamente y si el dato se detecta con errores se descarta. Cuando un dato es recibido
correctamente se entrega un byte que puede valer de 0 a 255, y si el dato est daado se entrega
un valor igual a -1.

Para la demostracin de est comunicacin se implementar una librera que transmite bytes con
las reglas antes mencionadas, de igual manera los microcontroladores implementados en est
librera son los PIC 16F628A con frecuencia de reloj de 4M Hz, sin embargo puede ser usada en
cualquier otro microcontrolador, la librera bsica es la siguiente:


//Declaracin de pines de comunicacin.
sbit RXPIN at RB7_bit;
sbit RXPIN_TRIS at TRISB7_bit;
sbit TXPIN at RB6_bit;
sbit TXPIN_TRIS at TRISB6_bit;
//Declaracin de constantes de peso binario.
const unsigned int Peso[12] = {1,2,4,8,16,32,64,128,256,512,1024,2048};


//Funcin para iniciar los pines de comunicacin.
163
void Inicio_Radio_Tx( void )
{
TXPIN_TRIS=0;
TXPIN=0;
}

//Funcin para iniciar los pines de comunicacin.
void Inicio_Radio_Rx( void )
{
RXPIN_TRIS=1;
}

//Funcin para determinar que bit se est recibiendo.
char Entra_Bit( void )
{
unsigned short T=0;
while( !RXPIN ); //Se espera el estdo 1 lgico.
//Se mide el tiempo en alto de la modulacin.
while( RXPIN ){ delay_us(50); T++; }
//Se clasifica el bit recibido en funcin de su tiempo.
if( T > 38 && T < 42 )return '1'; //Aprox. 2m Seg.
if( T > 18 && T < 22 )return '0'; //Aprox. 1m Seg.
if( T > 8 && T < 12 )return 'S'; //Aprox. 500u Seg.
return 'E'; // Tiempo errado.
}

//Funcin para enviar un byte.
int Resibir_Dato( void )
{
unsigned short D, BIT, N_Bits;
int DATO;
DATO=0;
BIT=0;
//Se espera un bit de sincronismo.
while( Entra_Bit()!='S' );
//Se espera el ltimo BIT de sincronismo.
while( (D=Entra_Bit())=='S' );
//Bucle para archivar el byte de entrada.
while( 1 )
{
//Se evala el BIT que llego.
switch( D )
{
case '1': DATO += Peso[BIT++];
break;
case '0': BIT++;
break;
case 'E':
case 'S': return -1;
164
}
//Si el nmero bits recibidos es 12, se
//evalan los errores.
if( BIT==12 )
{
//Se cuentan los bits del dato de informacin.
N_Bits=0;
for( BIT=0; BIT<8; BIT++ )
if( (DATO>>BIT)&1 )N_Bits++;
//Se verifica que el nmero de unos sea igual.
//y se retorna el byte de entrada.
if( N_Bits == (DATO>>8)&0x0F )return DATO&0x00FF;
//Ocurre un error y se espera una nueva trama.
return -1;
}
//Se lee el siguiente bit.
D=Entra_Bit();
}
}

//Funcin para transmitir un byte.
void Enviar_Dato( unsigned short d )
{
unsigned short BITS, N_Bits=0;
//Se cuentan el nmero de bits a enviar.
for( BITS=0; BITS<8; BITS++ )
if( (d>>BITS)&1 )N_Bits++;

//Se envan 16 bits de sincronismo.
for( BITS=0; BITS<16; BITS++ )
{
TXPIN = 1; delay_us(500);
TXPIN = 0; delay_us(500);
}

//Se envan 8 bits de datos, el byte.
for( BITS=0; BITS<8; BITS++ )
{
TXPIN=1;
if( (d>>BITS)&1 )
delay_ms(2);
else
delay_ms(1);
TXPIN=0;
delay_ms(1);
}

//Se envan 4 bits de verificacin
//con el nmero de unos en el byte.
165
for( BITS=0; BITS<4; BITS++ )
{
TXPIN=1;
if( (N_Bits>>BITS)&1 )
delay_ms(2);
else
delay_ms(1);
TXPIN=0;
delay_ms(1);
}
//Retardo final.
delay_ms(3);
}


Para concretar el ejemplo se realizan dos programas, uno para la transmisin, y otro para la
recepcin, este sistema transmite el estdo de 4 pulsadores y se puede visualizar en el receptor
por medio de 4 LEDs. De igual manera la simulacin puede soportar los dos microcontroladores
al mismo tiempo, pero no puede simular los radios. Para fines de simulacin se implementa una
conexin directa, sin embargo el desarrollador puede posteriormente hacer una prueba real con
los radios.


Cada uno de los programas debe tener anexa la librera anteriormente citada, y anexar las
siguientes funciones main, en cada uno de los cdigos fuente:


Funcin main para el transmisor:

void main( void )
{
//Declaracin de variables.
unsigned char DATO;
//Configuracin de puertos.
TRISB = 0xFF;
//Activacin de las resistencias PULL-UP del puerto B.
OPTION_REG = 0;
//Inicio del puerto de transmisin.
Inicio_Radio_Tx();

while(1) //Bucle infinito.
{
//Adquisicin de estdos de los pulsadores.
DATO = (~PORTB)&0x0F;
//Transmisin del byte.
Enviar_Dato( DATO );
}

}
166

Funcin main para el receptor:

void main( void )
{

//Declaracin de variables.
int DATO;
//Configuracin de puertos.
TRISB = 0;
PORTB = 0;
//Inicio del puerto de recepcin.
Inicio_Radio_Rx();

while(1) //Bucle infinito.
{
//Lectura del byte de entrada.
DATO = Resibir_Dato();
//Verificacin de errores, y visualizacin del byte.
if( DATO!=-1 )
PORTB =DATO;
}

}


Para realizar la simulacin se deben usar los siguientes dispositivos: PIC 16F628A, RES, LED-
RED, y BUTTON, en el circuito que se puede ver a continuacin:



Circuito 13-2

167
Para fines prcticos con los radios Laipac, se bebe hacer un par de circuitos como los que se
pueden ver en la siguiente grfica:


Circuito 13-3
13.3 Mdulos inalmbricos bidireccionales
En algunos casos las comunicaciones deben ser imperativamente bidireccionales, como el caso de
los controles realimentados y los sistemas de comunicacin full duplex. Para cumplir con el
propsito de realizar la comunicacin full duplex se pueden implementar mdulos de radio
prediseados como los XBee, o XBee PRO, estos dispositivos son mdulos MODEM, que
trabajan sobre la banda de 2,4GHz, e implementan el estndar IEEE 801.15.4. Estos son
dispositivos que trabajan con tecnologa de 3 voltios de bajo consumo, y velocidades de
transmisin de 1200 a 115200 bits por segundo. El alcance de los radios depende de la antena y
de la referencia de los mismos. Los mdulos XBee tienen un alcance de 100 metros con una lnea
de vista directa y 1000 metros en los mdulos XBee PRO. Los mdulos XBee, son de fcil
instalacin y programacin por medio de un paquete de software, suministrado por el fabricante,
este se denomina: X-CTU, este aplicativo se puede descargar gratuitamente en la pgina:
www.digi.com, este programa estblece con el radio la comunicacin para su programacin por
medio de un puerto serial COM. La simulacin de estos radios no es posible con ISIS; pero dado
el ptimo desempeo de los mismos es equivalente en ISIS a realizar una conexin cruzada entre
Tx y Rx, de los microcontroladores. Los mdulos XBee incorporan dentro de su hardware y
software un procedimiento de deteccin y correccin de errores en la transmisin. De la misma
forma es posible estblecer una conexin inalmbrica entre un microcontrolador con un
ordenador personal por medio de un puerto serial COM. Para trabajar y programar los radios
XBee es necesario crear o implementar un acople de hardware para hacer la conexin con un
puerto serial COM, para este proposito se debe tener presente el siguiente circuito electrnico:


168
Mdulo de acople con un ordenador personal:


Circuito 13-4

El anterior circuito electrnico puede ser construido en una protoborad, sin embargo se puede
construir un circuito impreso como el que se puede apreciar en las siguientes grficas:





Figura 13-8


169
La vista de este circuito impreso finalizado y del mdulo XBee, es la siguiente:



Figura 13-9

Los mdulos XBee por defecto vienen programados para establecer una comunicacin a 9600
bits por segundo. Sin embargo se puede cambiar por medio del programa X-CTU. La
reprogramacin del radio XBee, permite cambiar los parmetros de velocidad, canal de
comunicacin entre 16 posibles, se puede asignar un identificador del radio y asignar direccin de
trabajo en una red Zigbee.

Para hacer una demostracin del funcionamiento con los mdulos XBee, se puede editar y
analizar el siguiente cdigo fuente:

//Declaracin de pines de control para LCD.
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;


void main( void )
{
//Declaracin de variables.
char Texto[30];
char Dato;
unsigned short N=0;
//Inicio de los mdulos USART, y LCD.
Lcd_Init();
UART1_Init(9600);
170
//Se imprimen los textos de inicio.
Lcd_Out(1,1,"Datos de entrada:");
Lcd_Out(2,1,"");
while(1) //Bucle infinito.
{
//Se evala si un dato llega por el puerto serial.
if( UART1_Data_Ready() )
{
//Se lee el dato de entrada.
Dato = UART1_Read();
//Se evala que Dato llega por el puerto serial.
switch( Dato )
{
//Se evala la llegada de un enter.
case 13: N=0;
//Se limpian las lneas del LCD.
Lcd_Out(2,1," "); //Se imprimen 20 espacios vacos.
Lcd_Out(2,1," "); //Se imprimen 20 espacios vacos.
Lcd_Out(4,1," "); //Se imprimen 20 espacios vacos.
//Se posiciona el cursor en la segunda lnea.
Lcd_Out(2,1,"");
//Se transmite un enter y un retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se transmite el texto: Texto Xbee.
UART1_Write_Text("Texto Xbee: ");
//Se retransmite la cadena recibida.
UART1_Write_Text(Texto);
//Se transmite un enter y un retroceso del carro.
UART1_Write(13);
UART1_Write(10);
break;

default: //Se guardan los datos entrantes en la cadena de caracteres Texto.
Texto[N++]=Dato;
Texto[N]=0;
//Se refresca la informacin en el LCD.
Lcd_Out(2,1,Texto);
//Se retransmite eco del dato de entrada.
UART1_Write(Dato);
break;
}
}
}
}

Para fines de simulacin se puede implementar un circuito con los dispositivos: 16F877A,
LM044L, y el puerto virtual VIRTUAL TERMINAL, como se puede apreciar en el siguiente
esquema:
171

Circuito 13-5

Para fines prcticos se puede usar el mdulo de acople con un ordenador personal, antes citado
con una sesin de Hyper terminal de Windows. Como parte complementaria se puede hacer un
circuito real como se puede ver en la siguiente grfica:


Circuito 13-6
172
13.4 Comunicacin RS 485
El protocolo RS 485, es un formato de comunicacin serial que usa como estrategia de
transmisin, la diferencia de potencial entre dos terminales denominadas A, y B. Cuando la
diferencia de potencial es positiva el protocolo representa un 1 lgico y cuando la diferencia es
negativa representa un 0 lgico. La comunicacin RS 485, implementa un par trenzado de cobre
para la transmisin de datos, como caractersticas notables de este protocolo se tiene que puede
estblecer la comunicacin en una topologa en forma de bus, con un alcance mximo de 1000
metros sin la necesidad de implementar dispositivos de repeticin. De igual forma es posible
conectar al bus de datos un mximo de 32 nodos, con una conectividad half duplex, esto quiere
decir que la comunicacin es bidireccional pero no al mismo tiempo. El protocolo RS 485
permite estblecer comunicaciones con una velocidad de hasta 2,5M bits por segundo. Para la
implementacin de este tipo de comunicacin se usan convertidores integrados que permiten
hacer un enlace de niveles TTL, a RS 485, el circuito integrado ms popular para ests
aplicaciones es el MAX485, que es un integrado de 8 pines. La distribucin de pines y la
apariencia fsica de este dispositivo es la siguiente:


Figura 13-10

Los pines A, y B, son el bus de datos bidireccional, los pines DE, y RE, son los habilitadores de
los bfer de transmisin y recepcin respectivamente. Los pines DI, y RO, son respectivamente
los terminales de transmisin y recepcin. Como medida adicional se deben implementar un par
de resistencias de 120 en paralelo a los pines A, y B, en el primer y en el ltimo terminal de la
red RS 485.

Para demostrar una comunicacin con este tipo de redes se realizar en este captulo una
comunicacin de half duplex entre dos microcontroladores, para este fin se usarn los mdulos
USART, y un control adicional con los pines de habilitacin. Para contextualizar el uso de la
comunicacin RS 485, se puede observar y analizar el siguiente cdigo de programa que permite
enviar el estdo de un potencimetro para controlar la intensidad de luz de una lmpara en el
terminal opuesto:

void main( void )
{
//Declaracin de variables.
unsigned short DATO;
//Configuracin de puertos.
TRISB = 0b11111110;
PORTB = 0; //Se Configura la MAX485 como receptor.
173
//Se activan las resistencias PULL-UP.
OPTION_REG = 0;
//Se configura el mdulo USART a 250000 bps.
UART1_Init(250000);
//Se configura el mdulo PWM con una frecuencia de 1K Hz.
PWM1_Init(1000);
//Se inicia el mdulo PWM con 0%.
PWM1_Start();
PWM1_Set_Duty(0);
while(1) //Bucle infinito.
{
//Se evala si un dato ha llegado.
if( UART1_Data_Ready() )
{
DATO = UART1_Read();
//Se evala si el dato de llegada vale 170.
if( DATO==170 )
{
//Se espera el siguiente dato.
while( !UART1_Data_Ready() );
DATO = UART1_Read();
//Se actualiza el ciclo til del PWM.
PWM1_Set_Duty(DATO);
}
}
//Se evala si se ha pulsado el botn.
if( Button(&PORTB, 1, 50, 0) )
{
PORTB = 1; //Se Configura la MAX485 como transmisor.
//Se lee el canal anlogo con el voltaje del
//potencimetro, y se guardan los 8 bits de mayor peso
//en el la variable DATO.
DATO = (ADC_Read(0)>>2)&0xFF;
//Se transmite la bandera 170, para sincronizar la comunicacin.
UART1_Write(170);
//Se hace una pausa de 1m segundos entre datos.
delay_ms(1);
//Se transmite el valor de la variable DATO.
UART1_Write(DATO);
//Se espera a que se suelte el botn.
while( Button(&PORTB, 1, 50, 0) );
PORTB = 0; //Se Configura la MAX485 como receptor.
}
}
}

El anterior programa es simtrico, es decir que los dos microcontroladores de la simulacin se
cargan con el mismo programa. El circuito electrnico recurre a una lmpara incandescente con
el fin de mostrar la intensidad de la luz, la diferencia de potencial se obtiene del mdulo PWM,
174
con la conversin digital anlogo. Para fines ideales de la simulacin las caractersticas por
defecto de la lmpara son reconfiguradas cambiando la impedancia de 24 a 100K y su voltaje
nominal de 12V a 5V. Para realizar la simulacin se deben implementar los siguientes
dispositivos: 16F877A, RES, MAX487, LAMP, BUTTON, CAP, y POT-HG. La teora vista en
este captulo cita el dispositivo MAX485, sin embargo para fines de simulacin se usa el
MAX487, que tiene caractersticas y funcionamiento similar. El circuito a implementar es el
siguiente:


Circuito 13-7

Cuando la simulacin est corriendo, cada uno de los mdulos MAX, estn configurados como
receptores, y en el momento que se pulsa un botn el microcontrolador hace la conversin
anloga digital, y transmite est informacin para configurar la intensidad de luz en el mdulo
opuesto.
13.5 Mdulos inalmbricos infrarrojos
La comunicacin infrarroja es una estrategia prctica para sistemas que no requieren una gran
velocidad de transmisin, y que admiten lnea de vista directa. El alcance de un enlace infrarrojo
depende de la potencia del emisor. Sin embargo este estndar es utilizado en la comunicacin de
control de los electrodomsticos convencionales como: televisores, equipos de sonido,
reproductores de video, aires acondicionados entre otros, tiene un alcance promedio de 10
metros.

La transmisin de datos se realiza por medio de diodos emisores de luz infrarroja, con una
modulacin digital por amplitud, ASK. Los estndares de comunicacin para los controles
infrarrojos implementan frecuencias portadoras de 36, 38, y 40 K Hz entre otras. La recepcin de
los datos se hace por medio de un demodulador ASK, que puede recibir datos hasta los 2,4K bits
por segundo. Los demoduladores ASK, infrarrojos son dispositivos de carcter integrado que se
pueden conseguir comercialmente. Estos poseen tres terminales que corresponden a dos de
polarizacin, Vcc o poder, y referencia, y una salida demodulada en amplitud, con colector
abierto, esto quiere decir que se requiere el uso de una resistencia PULL-UP, a Vcc, en este
ltimo terminal. Algunos fabricantes incorporan est resistencia en la integracin del dispositivo.
175
Para fines de diseo es importante tener presente que la salida del demodulador est invertida, es
decir que cuando el dispositivo detecta la seal portadora la salida del demodulador se activa en
bajo y se activa en alto cuando se detecta la ausencia de la misma. La apariencia fsica de estos
dispositivos es la siguiente:

Figura 13-11

La distribucin de pines puede variar de un fabricante a otro, sin embargo siempre sern las
mismas tres, Vcc, Referencia, y Salida, para fines prcticos se hace imperativo consultar la ficha
tcnica del dispositivo que se use.

Para la simulacin de este tipo de enlaces se puede usar en ISIS el mdulo virtual: IRLINK, el
cual tiene la siguiente apariencia en el simulador:


Figura 13-12

Este dispositivo virtual simula el enlace inalmbrico por medio del LED infrarrojo, y el
dispositivo demodulador, de igual manera permite editar la frecuencia de la seal portadora ASK.
Para contextualizar el desempeo de estos enlaces se debe observar y analizar el siguiente cdigo
fuente, que usa el mdulo PWM, como fuente portadora, y el mdulo USART, como seal
moduladora, la informacin transmitida son datos ASCII, con textos fijos que se pueden ver en
un hyper terminal virtual:

void main( void )
{
//Configuracin del mdulo USART a 2400 bps.
UART1_Init(2400);
//Configuracin de PWM para crear la frecuencia portadora a 38K Hz.
PWM1_Init(38000);
PWM1_Start();
176
//Se configura el ciclo til del PWM al 50%.
PWM1_Set_Duty(127);

while(1) //Bucle infinito.
{
//Se transmite informacin en un texto fijo.
UART1_Write_Text("Transmision de datos infrarrojos.");
//Se enva los caracteres enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se transmite informacin en un texto fijo.
UART1_Write_Text("Est emision est modulada a 38K Hz.");
UART1_Write(13);
UART1_Write(10);
//Se transmite informacin en un texto fijo.
UART1_Write_Text("Con una velocidad de transmision de 2400 bps.");
//Se enva los caracteres enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se enva los caracteres enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se realiza una pausa de 200m segundos.
delay_ms(200);
}
}



Para la simulacin de este ejemplo se implementan en ISIS los dispositivos: 16F628A, RES,
1N4148, IRLINK, 74LS04, y el VIRTUAL TERMINAL. El circuito electrnico debe ser
ensamblado de la siguiente manera:


Circuito 13-8
177
La modulacin se realiza por medio de la multiplicacin de la seal moduladora, con la seal
portadora, para esto se implementa una compuerta AND, diseada con diodos rectificadores de
switcheo rpido. En funcionamiento de la simulacin, el hiperterminal virtual debe mostrar los
datos de texto de la siguiente forma:


Figura 13-13
13.6 Comunicacin con memorias SD
Las memorias de almacenamiento masivo SD, pueden ser manipuladas por los
microcontroladores de alta gama como la familia 18F. Para leer o escribir sobre una memoria SD,
se requiere trabajar con segmentos de memoria de 512 bytes. Para este fin es necesario contar con
espacios de memoria RAM, de gran capacidad como los microcontroladores de la familia 18F. La
comunicacin de las memorias SD, requieren de un protocolo serial conocido como SPI, para
este fin los microcontroladores cuentan con un mdulo de comunicacin serial de este tipo. La
alimentacin de voltaje de las memorias SD es de 3 voltios, para esto se requiere hacer un acople
de voltajes con el microcontrolador por medio de un divisor de voltaje con resistencias. La
apariencia fsica y la distribucin de pines de este tipo de memorias son las siguientes:


Figura 13-14

La capacidad de las memorias SD actuales es del orden de los Giga bytes, sin embargo la mxima
capacidad que soporta la librera para ests memorias en MikroC PRO, es de 1G bytes. Para la
manipulacin de este tipo de memorias el compilador MikroC PRO, cuenta con una librera
178
denominada: Mmc. La cual posee tres funciones para estblecer de forma simple la comunicacin
y control de la memoria. La funcin: unsigned char Mmc_Init( void ); est funcin inicializa la
comunicacin con la memoria SD, y retorna 0 si la comunicacin se estbleci exitosamente, o
retorna 1 si algn error se presenta. La funcin: unsigned char Mmc_Read_Sector(unsigned long
sector, char *dbuff); est permite leer un sector de 512 bytes, guardando la lectura en el
apuntador dbuff, e iniciando en el sector definido por el parmetro sector. La funcin: unsigned
char Mmc_Write_Sector(unsigned long sector, char *dbuff); est funcin trabaja de forma
similar a la funcin de lectura, en las dos funciones se retorna el valor 0 si la operacin culmina
exitosamente o retornan 1 si un fallo se presenta. Para la comunicacin fsica se requieren 4
conexiones que son: una lnea de reloj, dos lneas de datos, entrada y salida, y un selector de
pastilla.
Para contextualizar el funcionamiento de estos dispositivos se puede observar y analizar el
siguiente cdigo fuente:

// Pines de conexin para el selector de pastilla
sbit Mmc_Chip_Select at RC2_bit;
sbit Mmc_Chip_Select_Direction at TRISC2_bit;


void main( void )
{
//Declaracin de variables.
char SD;
char Texto[50];
long SEC=0;
unsigned int Cont;
unsigned short Menu=0;
unsigned short NN;
char Dato;
unsigned short Bufer[512];
//Inicio del puerto serial a 9600 bps.
UART1_Init(9600);
//Inicio del puerto SPI, para la memoria SD.
SPI1_Init_Advanced(_SPI_MASTER_OSC_DIV64, _SPI_DATA_SAMPLE_MIDDLE,
_SPI_CLK_IDLE_HIGH, _SPI_LOW_2_HIGH);
//Inicio de la memoria.

if( Mmc_Init()==0 )
{
//Confirmacin exitosa de conexin.
SD = 1;
UART1_Write_Text("// La memoria fue iniciada exitosamente. //");
UART1_Write(13);
UART1_Write(10);
UART1_Write(13);
UART1_Write(10);
179
}
else
{
//Confirmacin fallida de conexin.
SD = 0;
UART1_Write_Text("ERROR no se puede iniciar la memoria !!!");
UART1_Write(13);
UART1_Write(10);
UART1_Write(13);
UART1_Write(10);
}

while(1) //Bucle infinito.
{

if( SD ) //Se ejecuta el Men si la conexin fue exitosa.
{
//Se despliega el Men.
UART1_Write_Text( "1. Grabar un Sector." );
UART1_Write(13);
UART1_Write(10);
UART1_Write_Text( "2. Leer un Sector." );
UART1_Write(13);
UART1_Write(10);
UART1_Write_Text( "Digite una opcion: " );
Menu = 0;
//Bucle para esperar la opcin.

while( Menu==0 )
{

if( UART1_Data_Ready() )
{
Dato = UART1_Read();
UART1_Write(Dato);
UART1_Write(' ');
switch( Dato )
{
case '1': Menu=1; break;
case '2': Menu=2; break;
default: break;
}
}

}
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Captura del sector de lectura o escritura.
180
UART1_Write_Text( "Digite el numero del sector de memoria, y pulse ENTER: " );
SEC=-1;
NN=0;
Texto[0]=0;
//Bucle para digital el sector.

while( SEC==-1 )
{

if( UART1_Data_Ready() )
{
Dato = UART1_Read();
UART1_Write(Dato);
switch( Dato )
{
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0': Texto[NN++]=Dato;
Texto[NN]=0;
break;
case 13: SEC=atol(Texto);
default : break;
}
}

}
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se graban o se leen los sectores.
if( Menu==1 )
{
UART1_Write_Text( "Se grabara el sector: " );
LongToStr( SEC, Texto);
UART1_Write_Text( Texto );
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se borra el Bfer.
for( Cont=0; Cont<512; Cont++ )
Bufer[Cont]=0;
//Bucle para capturar los datos a grabar.
181
while( Menu )
{
if( UART1_Data_Ready() )
{
Dato = UART1_Read();
UART1_Write(Dato);
switch( Dato )
{
case 13: Menu=0; break;
default : Bufer[NN++]=Dato;
break;
}
}
}
//Se graban los 512 datos del sector en la memoria.
Mmc_Write_Sector( SEC, Bufer);
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
UART1_Write_Text( "Fin de la grabacion." );
}
else
{
UART1_Write_Text( "Se leera el sector: " );
LongToStr( SEC, Texto);
UART1_Write_Text( Texto );
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Se leen 512 datos del sector.
Mmc_Read_Sector( SEC, Bufer);
//Bucle para imprimir los datos ledos de la memoria.
for( Cont=0; Cont<512; Cont++ )
UART1_Write( Bufer[Cont] );
}
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
//Envi del enter y retroceso del carro.
UART1_Write(13);
UART1_Write(10);
}
}
}

Como medida adicional se debe inicializar el puerto SPI, por medio de la funcin:
SPI1_Init_Advanced. Para comprobar el funcionamiento de de este programa se debe construir en
ISIS, un circuito con los dispositivos: 18F452, MMC, y VIRTUAL TERMINAL, como se puede
apreciar en la siguiente grfica:
182

Circuito 13-9

Para fines de simulacin las conexiones con la memoria se hacen directamente como se puede ver
en el anterior circuito. Sin embargo se debe tener presente que para fines prcticos la memoria
trabaja con 3 voltios, y se debe acoplar con un arreglo de resistencias como el siguiente:


Circuito 13-10
183
13.7 Relojes en tiempo real
Algunas aplicaciones requieren de un reloj en tiempo real, para tener dominio del tiempo de
eventos, acciones, y dems. Este tipo de relojes son circuitos integrados con bateras propias, y
cristales de cuarzo para definir las unidades de tiempo. Los relojes en tiempo real se comunican
por medio del protocolo IC. Una de las referencias comerciales ms populares es el DS1307, que
puede contar aos, meses, das, hora, minutos, y segundos. La apariencia fsica y la vista en ISIS
de estos dispositivos es la siguiente:



Figura 13-15

Este circuito integrado cuenta con dos pines de comunicacin un pin de salida oscilante, y una
entrada para la batera, adems para fines prcticos cuenta con dos terminales para instalar un
cristal de cuarzo de 32,768KHz. El siguiente cdigo fuente en lenguaje C, muestra una serie de
funciones que forman una librera que permiten manipular este tipo de relojes:

//Declaracin de estructuras
typedef struct
{
unsigned short Hor, Min, Seg;
}Hora;

typedef struct
{
unsigned short Dia, Fec, Mes, Ano;
}Fecha;

//Funcin para definir direccin de memoria.
void DS1307SetDir( unsigned short dir )
{
I2C1_Start();
I2C1_Wr(0xD0);
I2C1_Wr(dir);
}

//Funcin para convertir de cdigo Bcd a Entero.
unsigned short BcdToShort( unsigned short bcd )
{
unsigned short LV, HV;
LV = bcd&0x0F;
HV = (bcd>>4)&0x0F;
184
return LV + HV*10;
}

//Funcin para convertir de Entero a Bcd.
unsigned short ShortToBcd( unsigned short valor )
{
unsigned short HV, LV;
HV = valor/10;
LV = valor - HV*10;
return LV + HV*16;
}

//Funcin para inicializar el DS1307.
void DS1307Inicio( void )
{
unsigned short VAL[7], HV, LV, DATO;
I2C1_Init(100000); //Inicio del bus I2C.
delay_ms(50); //Retardo.
//Lectura de las primeras 7 direcciones.
DS1307SetDir(0);
I2C1_Repeated_Start();
I2C1_Wr(0xD1);
VAL[0] = I2C1_Rd(1);
VAL[1] = I2C1_Rd(1);
VAL[2] = I2C1_Rd(1);
VAL[3] = I2C1_Rd(1);
VAL[4] = I2C1_Rd(1);
VAL[5] = I2C1_Rd(1);
VAL[6] = I2C1_Rd(0);
I2C1_Stop();
delay_ms(50); //Retardo.
//Validacin y correccin de informacin,
//como hora y fecha.
DATO = BcdToShort( VAL[0] );
if( DATO > 59 )VAL[0]=0;
DATO = BcdToShort( VAL[1] );
if( DATO>59 )VAL[1]=0;
DATO = BcdToShort( VAL[2] );
if( DATO>23 )VAL[2]=0;
DATO = BcdToShort( VAL[3] );
if( DATO>7 || DATO==0 )VAL[3]=1;
DATO = BcdToShort( VAL[4] );
if( DATO>31 || DATO==0 )VAL[4]=1;
DATO = BcdToShort( VAL[5] );
if( DATO>12 || DATO==0 )VAL[5]=1;
DATO = BcdToShort( VAL[6] );
if( DATO>99 )VAL[6]=0;
//Grabacin de las primeras 7 direcciones.
DS1307SetDir(0);
185
I2C1_Wr(VAL[0]);
I2C1_Wr(VAL[1]);
I2C1_Wr(VAL[2]);
I2C1_Wr(VAL[3]);
I2C1_Wr(VAL[4]);
I2C1_Wr(VAL[5]);
I2C1_Wr(VAL[6]);
I2C1_Wr(0x10); //Se activa la salida oscilante 1Hz.
I2C1_Stop();
delay_ms(50); //Retardo.
}

//Funcin para grabar la hora minutos y segundos.
void DS1307SetHora( Hora h )
{
DS1307SetDir(0);
I2C1_Wr( ShortToBcd(h.Seg) );
I2C1_Wr( ShortToBcd(h.Min) );
I2C1_Wr( ShortToBcd(h.Hor) );
I2C1_Stop();
}

//Funcin para grabar el da, fecha, mes, y ao.
void DS1307SetFecha( Fecha f )
{
DS1307SetDir(3);
I2C1_Wr( ShortToBcd(f.Dia) );
I2C1_Wr( ShortToBcd(f.Fec) );
I2C1_Wr( ShortToBcd(f.Mes) );
I2C1_Wr( ShortToBcd(f.Ano) );
I2C1_Stop();
}

//Funcin para leer la hora minutos y segundos.
Hora DS1307GetHora( void )
{
Hora H;
unsigned short VAL[3];
DS1307SetDir(0);
I2C1_Repeated_Start();
I2C1_Wr(0xD1);
VAL[0] = I2C1_Rd(1);
VAL[1] = I2C1_Rd(1);
VAL[2] = I2C1_Rd(0);
I2C1_Stop();
H.Seg = BcdToShort( VAL[0] );
H.Min = BcdToShort( VAL[1] );
H.Hor = BcdToShort( VAL[2] );
return H;
186
}

//Funcin para leer el da, fecha, mes, y ao.
Fecha DS1307GetFecha( void )
{
Fecha F;
unsigned short VAL[4];
DS1307SetDir(3);
I2C1_Repeated_Start();
I2C1_Wr(0xD1);
VAL[0] = I2C1_Rd(1);
VAL[1] = I2C1_Rd(1);
VAL[2] = I2C1_Rd(1);
VAL[3] = I2C1_Rd(0);
I2C1_Stop();
F.Dia = BcdToShort( VAL[0] );
F.Fec = BcdToShort( VAL[1] );
F.Mes = BcdToShort( VAL[2] );
F.Ano = BcdToShort( VAL[3] );
return F;
}

// Funciones para leer y grabar datos individuales //
//Funcin para leer las horas.
unsigned short DS1307GetHoras( void )
{
Hora h;
h=DS1307GetHora();
return h.Hor;
}
//Funcin para leer los minutos.
unsigned short DS1307GetMinutos( void )
{
Hora h;
h=DS1307GetHora();
return h.Min;
}
//Funcin para leer los segundos.
unsigned short DS1307GetSegundos( void )
{
Hora h;
h=DS1307GetHora();
return h.Seg;
}
//Funcin para grabar las horas.
void DS1307SetHoras( unsigned short ho )
{
Hora h;
h=DS1307GetHora();
187
h.Hor = ho;
DS1307SetHora( h );
}
//Funcin para grabar los minutos.
void DS1307SetMinutos( unsigned short mi )
{
Hora h;
h=DS1307GetHora();
h.Min = mi;
DS1307SetHora( h );
}

//Funcin para grabar los segundos.
void DS1307SetSegundos( unsigned short se )
{
Hora h;
h=DS1307GetHora();
h.Seg = se;
DS1307SetHora( h );
}

//Funcin para leer el da de la semana.
unsigned short DS1307GetDias( void )
{
Fecha f;
f=DS1307GetFecha();
return f.Dia;
}

//Funcin para leer la fecha del mes.
unsigned short DS1307GetFechas( void )
{
Fecha f;
f=DS1307GetFecha();
return f.Fec;
}

//Funcin para leer el mes del ao.
unsigned short DS1307GetMeses( void )
{
Fecha f;
f=DS1307GetFecha();
return f.Mes;
}

//Funcin para leer el ao.
unsigned short DS1307GetAnos( void )
{
Fecha f;
188
f=DS1307GetFecha();
return f.Ano;
}

//Funcin para grabar el dia de la semana.
void DS1307SetDias( unsigned short di )
{
Fecha f;
f=DS1307GetFecha();
f.Dia = di;
DS1307SetFecha(f);
}

//Funcin para grabar la fecha del mes.
void DS1307SetFechas( unsigned short fe )
{
Fecha f;
f=DS1307GetFecha();
f.Fec = fe;
DS1307SetFecha(f);
}

//Funcin para grabar el mes del ao.
void DS1307SetMeses( unsigned short me )
{
Fecha f;
f=DS1307GetFecha();
f.Mes = me;
DS1307SetFecha(f);
}

//Funcin para grabar el ao.
void DS1307SetAnos( unsigned short an )
{
Fecha f;
f=DS1307GetFecha();
f.Ano = an;
DS1307SetFecha(f);
}

Para realizar la simulacin de un ejemplo con este tipo de reloj, se puede implementar la anterior
librera y el siguiente cdigo fuente correspondiente a la funcin main:

void main( void )
{
//Declaracin de variables.
char Text[50];
unsigned short DATO;
//Inicio y configuracin del reloj.
189
DS1307Inicio();
//Inicio y configuracin de la USART a 9600 bps.
UART1_Init(9600);
//Se leen los segundos del reloj.
DATO = DS1307GetSegundos();
while(1) //Bucle infinito.
{
//Se espera el cambio en los segundos.
while( DATO == DS1307GetSegundos() )delay_ms(200);
//Se leen la hora y se transmiten por la USART.
DATO = DS1307GetHoras();
ByteToStr( DATO, Text );
UART1_Write_Text( Text ); UART1_Write_Text(":");
//Se leen los minutos y se transmiten por la USART.
DATO = DS1307GetMinutos();
ByteToStr( DATO, Text );
UART1_Write_Text( Text ); UART1_Write_Text(":");
//Se leen los segundos y se transmiten por la USART.
DATO = DS1307GetSegundos();
ByteToStr( DATO, Text );
UART1_Write_Text( Text ); UART1_Write(13); UART1_Write(10);
}
}
Para realizar la simulacin pertinente en ISIS, se implementan los siguientes dispositivos:
16F877A, RES, LED-RED, DS1307, CRYSTAL, CELL, y los instrumentos virtuales, VIRTUAL
TERMINAL, I2C DEBUGGER. El circuito electrnico correspondiente para simular es el
siguiente:


Circuito 13-11
190
14 Tratamiento digital de
seales
El tratamiento digital de seales es una lnea de la tecnologa demasiado extensa para ser tratada
en un solo captulo; sin embargo, este captulo se centra en las nociones de adquisicin
tratamiento y reconstruccin de seales. Cabe denotar que el alcance de los microcontroladores
PICMicro de baja gama como los 16F y 18F slo permiten realizar tratamientos sobre seales de
baja frecuencia. De todos modos, muchas aplicaciones son de utilidad bajo ests caractersticas
tales como sistemas de comunicacin, generacin de tonos DTMF y adquisicin de seales
bioelctricas, entre otras. Si el desarrollador desea trabajar y tratar seales de mayor espectro,
realizando tratamientos de mayor complejidad ser necesario trabajar con unidades de
procesamiento ms robustas como la familia de microcontroladores PICMicro ds. Estos
microcontroladores no pueden ser programados con el compilador MikroC PRO, para estos se
debe utilizar el compilador MikroC PRO para dsPIC.

Un diagrama en bloques del procesamiento digital de una seal se puede apreciar en la siguiente
figura:


Figura 14-1
14.1 Muestreo
Como primera medida se requiere adquirir muestras peridicamente de la seal anloga, esto se
logra haciendo una conversin anloga digital, con una frecuencia constante denominada
frecuencia de muestreo Fs. El periodo de muestreo T, es el tiempo en segundos que existe entre
muestra y muestra, y a su vez es el inverso de la frecuencia de muestreo T = 1/Fs. El muestreo
permite convertir una seal continua en una seal discreta, es decir que pasa de x(t) a x(Tn),
donde T es el periodo de muestreo, y n es el nmero de la muestra digitalizada. Para definir el
periodo de muestreo T, o lo que es igual la frecuencia de muestreo Fs, se debe tener la siguiente
consideracin: La frecuencia de muestreo debe ser mayor que la mxima componente espectral
contenida en la seal x(t). Por ejemplo, si la mxima frecuencia contenida en la seal x(t) es
500Hz, la frecuencia de muestreo debe ser como mnimo el doble, es decir Fs = 2x500Hz =
1000Hz. Este concepto es conocido como teorema de muestreo de Nyquist. Sin embargo la
frecuencia de muestreo puede ser mayor al doble del mximo en frecuencia de la seal x(t), de
hecho cuanto mayor sea la frecuencia de muestreo mayor ser la fidelidad de la seal
digitalizada, pero a su vez mayor sern los recursos requeridos en velocidad, y memoria de
procesamiento.

MAX
F Fs 2 >
Ecuacin 14-1

191
14.2 Funciones de transferencia
Una funcin de transferencia es la relacin que existe entre la entrada de una seal y su salida al
pasar por el bloque de proceso. Las funciones de transferencia se estudian y se manipulan en
trminos de la frecuencia compleja y no en el dominio del tiempo continuo. Esto se debe a que al
convertir las funciones a la frecuencia compleja las operaciones que implican manipulacin de
nmeros complejos y sistemas integro diferenciales que se hacen lineales, y esto simplifica su
tratamiento. Las funciones de transferencia para el caso de los sistemas de tiempo discreto se
hacen en trminos de la variable compleja z, para el tratamiento de estos sistemas se recurre a la
transformacin z, que representa la frecuencia compleja para el tiempo discreto. Las funciones de
transferencia se denotan por excelencia con la letra H, para las funciones en trminos de la
variable z, y con h, para las funciones en trminos del tiempo discreto Tn. A continuacin se
puede ver un ejemplo:
B
A
z X
z Y
z H = =
) (
) (
) (
Ecuacin 14-2

De la ecuacin anterior se puede deducir que:

) ( ) ( ) ( z Y z X z H =
Ecuacin 14-3

Como se puede ver en la anterior ecuacin la salida Y, de un sistema discreto es igual a la entrada
X, multiplicada por la funcin de transferencia H. Se debe recordar que el tratamiento real y la
programacin se realizan en trminos del tiempo discreto, por est razn siempre se deber
realizar la transformada inversa de z. La transformacin inversa de la ecuacin anterior da como
resultado la siguiente ecuacin en funcin del tiempo discreto Tn:

) ( ) ( * ) ( n y n x n h =
Ecuacin 14-4

De la anterior ecuacin se puede observar que se omite la escritura del periodo T, dado que este
es un valor constante, y no tiene relevancia escribirlo siempre. Por otro lado se puede observar
que la funcin h y la seal x, no se multiplican como en la frecuencia compleja, en este caso al
realizar la transformacin su equivalencia es la convolucin. Para el caso del tratamiento de
seales, la longitud de h(n), es finita, y el nmero mximo que asume n se denomina M, este a su
vez determina el orden de la funcin de transferencia. Por otra parte la seal de entrada x(n), es
una serie de muestras de longitud indeterminada, igual que la salida y(n).

De lo anterior se puede concluir que para realizar un tratamiento digital sobre una seal se debe
realizar la operacin de convolucin continua entre los coeficiente de la funcin h(n) y la seal
x(n). Sin embargo la operacin de convolucin puede ser de dos formas, una en la cual la
convolucin se hace con las muestras pasadas y actuales de la seal x(n), esto se conoce como
sistema sin memoria o sistemas FIR (Respuest Finita al Impulso). Por otra parte cuando la
convolucin requiere informacin de las muestras pasadas de x(n), y de y(n), estos sistemas se
denominan sistemas con memoria o IIR (Respuest Infinita al Impulso). Los sistemas IIR son
sistemticamente ms simples, en su implementacin y requieren de campos de memoria
pequeos, por otra parte realizar su diseo y lograr su estbilidad es ms complicado y requiere
de tediosos procesos matemticos. Los sistemas FIR, ofrecen caractersticas contrarias a los
sistemas IIR, los sistemas FIR, son de fcil implementacin y diseo, pero consumen recursos de
192
memoria y procesamiento mayor, una de las virtudes de estos sistemas es que siempre son
estbles. Los anlisis y ejemplos de este captulo se concentrarn en los sistemas FIR e IIR.
14.3 Convolucin
Para iniciar es importante conocer la estructura de una convolucin continua en forma
matemtica y por medio de un segmento de cdigo en lenguaje C:

| |

+
=
=
k
k n x k h n y ) ( ) ( ) (
Ecuacin 14-5

La ecuacin anterior describe la forma general de la convolucin, sin embargo se debe recordar
que la longitud de la funcin h(n), es finita y su mximo es M, por lo tanto la ecuacin se puede
reescribir de la siguiente forma:
| |

=
=
M
k
k n x k h n y
0
) ( ) ( ) (
Ecuacin 14-6

Cada vez que una muestra de la salida y(n), es calculada por medio de la convolucin, se
requieren M, muestras de la seal x(n), incluida la muestra actual, esto quiere decir que para
hacer la convolucin se debe tener presente la necesidad de un campo de memoria igual a M para
guardar las ltimas muestras durante el proceso.

A continuacin se puede observar un ejemplo de cmo se implementar una convolucin, en
lenguaje C:

//Orden del sistema FIR de orden 17, M=17.
#define M 17
float x[M];
float h[M];

//Rutina para hacer la convolucin.

float yn=0.0;
short k;
for( k=M-1; k>=1; k-- )x[n]=x[n-1];
x[0]=x0;
for( k=0; k<M; k++ )yn += h[k]*x[k];

14.4 Filtros FIR
El diseo de los filtros FIR, es relativamente simple y utiliza estructuras ya definidas para cada
tipo de filtro. Los filtros pueden ser de cinco naturalezas: Pasa bajas, pasa altas, pasa bandas,
rechaza banda, y multi banda. Para el tratamiento de los filtros se debe tener presente las
siguientes consideraciones:

Los clculos de los filtros se hacen en radianes y no en hercios.
193
La frecuencia de muestreo en hercios Fs, es equivalente a una frecuencia en radianes/segundo de
2.
La mxima frecuencia tratada por los filtros es Fs/2, o Radianes.
La relacin que existe entre radianes y hercios es: W = 2F, y F = W/2.
Las frecuencias de corte de los filtros se denotan como Wc, y Fc.
La frecuencia de corte se calcula como Wc = 2 Fc / Fs.
La banda de transicin del filtro se denota como dW en radianes/segundo y dF en hercios.
El orden de los sistemas FIR se denota como M.
Se recomienda usar un nmero impar para M.

A continuacin se estudiar la forma de diseo para cada uno de estos filtros.
14.4.1 Filtro Pasa bajas
Los filtros pasa bajas se caracterizan por tener una frecuencia de corte a partir de la cual las
frecuencias inferiores son permitidas, y las frecuencias superiores son atenuadas. La funcin de
transferencia h(n), para este filtro es:


2 2
0 ,
0 ,
) (
) (
M
n
M
n
w
n
n
n w Sen
n h
c
c
< <

=
=
=
t
t
Ecuacin 14-7

La respuest espectral de este filtro de orden 7, en escala lineal es la siguiente:




Figura 14-2

194
14.4.2 Filtros Pasa Altas
Los filtros pasa altos permiten el paso de las frecuencias superiores a la frecuencia de corte, y
suprimen las inferiores a la misma. El clculo de la funcin de transferencia h(n), para estos
filtros est definida por la siguiente ecuacin:

2 2
0 , 1
0 ,
) (
) (
M
n
M
n
w
n
n
n w Sen
n h
c
c
< <

=
=

=
t
t
Ecuacin 14-8


La respuest espectral en escala lineal de este filtro en orden 17, es la siguiente:



Figura 14-3
14.4.3 Filtro Pasa Banda
Los filtros pasa banda permiten el paso de una porcin de frecuencias entre Wc1 y Wc2, y el
resto de frecuencias son eliminadas. La funcin de transferencia para este tipo de filtros se
calcula por medio de la siguiente ecuacin:

2 2
0 ,
0 ,
) ( ) (
) (
1 2
1 2
M
n
M
n
w w
n
n
n w Sen n w Sen
n h
c c
c c
< <

=
t
t
Ecuacin 14-9

195
La respuest espectral en escala lineal de este filtro en orden 17, es la siguiente:



Figura 14-4
14.4.4 Filtro Rechaza Banda
Los filtros rechaza banda tienen un comportamiento similar a los filtros pasa banda, y su proceder
es inverso a los filtros pasa banda, la funcin que caracteriza los coeficientes de la funcin de
transferencia es la siguiente:

2 2
0 , 1
0 ,
) ( ) (
) (
1 2
2 1
M
n
M
n
w w
n
n
n w Sen n w Sen
n h
c c
c c
< <

=
t
t
Ecuacin 14-10

La respuest espectral en escala lineal de este filtro en orden 17, es la siguiente:



Figura 14-5
196
14.4.5 Filtro Multi Band
Los filtros multi banda son arreglos que integran diferentes filtros en uno solo, estos pueden dar
ganancias arbitrarias en un rango de frecuencias. La siguiente ecuacin integra las ganancias A
del filtro, y las frecuencias de corte w:

2 2
0 , ) (
0 ,
) (
) (
) (
1
1
1
1
M
n
M
n
w
A A
n
n
n w sen
A A
n h
L
l
l
l l
L
l
l
l l
< <

=
(

=
(

=
+
=
+
t
t
Ecuacin 14-11

La siguiente grfica muestra la respuest, de un filtro multi banda de orden 65, con cuatro bandas
diferentes:


Figura 14-6

Para fines de diseo se debe tener presente que la ultima frecuencia calculada debe ser igual a .
Este tipo de filtros son ideales para el diseo de sistemas que requieran efectuar ecualizacin,
sobre una seal.
14.4.6 Ventanas fijas
Las ventanas se aplican a las funciones de transferencia h(n), el objetivo de las ventanas es
mejorar y suavizar la respuest espectral de los filtros FIR. Las ventanas de mayor uso son las
siguientes:
- Rectangular
- Hamming
- Hanning
- Blackman
197
Los filtros que se demostraron anteriormente por defecto son filtros con ventana rectangular.
Estos filtros tienen la menor transicin en la frecuencia de corte, lo que los hace ms cercanos a
los filtros ideales, sin embargo est propiedad produce en los filtros sobresaltos y oscilaciones en
el espectro. Este efecto es conocido como: fenmeno Gibbs. Este efecto puede apreciarse en la
siguiente grfica:



Figura 14-7

La ventana Rectangular ofrece una banda de transicin igual a la siguiente relacin: dW = 1,8/M
14.4.7 Ventanas Rectangulares
Una ventana rectangular ofrece un patrn lineal, y constante. Se debe recordar que al realizar el
clculo de un filtro FIR, por defecto ya se encuentra con una ventana de este tipo.

La aplicacin de las ventanas involucra la creacin de una nueva funcin de factores w(n), que
posteriormente debe ser multiplicada trmino a trmino con la funcin de transferencia h(n), para
crear la funcin h(n) definitiva.

Una ventana Rectangular se representa por medio de la siguiente funcin w(n):


Figura 14-8

La respuest espectral de la ventana Rectangular en escala logartmica es la siguiente:
198


Figura 14-9

La ventana Rectangular ofrece una atenuacin del fenmeno Gibbs de -13dB.

14.4.8 Ventanas Hamming
Para el caso de la ventana Hamming, los factores w(n), se calculan de la siguiente forma:

M n
M n Cos
n w s s

= 0 ,
2
) / 2 ( 1
) (
t
Ecuacin 14-12

La misma respuest espectral aplicando una ventana Hamming, en la figura (14.7) del fenmeno
Gibbs se ve de la siguiente forma:



Figura 14-10

La ventana Hamming ofrece una banda de transicin igual a la siguiente relacin: dW = 6,2/M

Una ventana Hamming se representa por medio de la siguiente funcin w(n):

199


Figura 14-11

La respuest espectral de la ventana Hamming en escala logartmica es la siguiente:



Figura 14-12

En la ventana Hamming se ofrece una atenuacin del fenmeno Gibbs de -31dB.

14.4.9 Ventanas Hanning
Para el clculo de la ventana Hanning, los factores w(n), se deducen de la siguiente forma:


M n
M n Cos
n w s s

= 0 ,
50
) / 2 ( 23 27
) (
t
Ecuacin 14-13


La misma respuest espectral aplicando una ventana Hanning, en la figura (14.7) del fenmeno
Gibbs se ve de la siguiente forma:
200


Figura 14-13

La ventana Hanning ofrece una banda de transicin igual a la siguiente relacin: dW = 6,6/M

Una ventana Hanning se representa por medio de la siguiente funcin w(n):



Figura 14-14

La respuest espectral de la ventana Hanning en escala logartmica es la siguiente:



Figura 14-15

En la ventana Hanning se ofrece una atenuacin del fenmeno Gibbs de -41dB.
201
14.4.10 Ventanas Blackman
Para el diseo de una ventana Blackman, los factores w(n), se calculan de la siguiente forma:

M n
M n Cos M n Cos
n w s s
+
= 0 ,
50
) / 4 ( 4 ) / 2 ( 25 21
) (
t t
Ecuacin 14-14

La misma respuest espectral aplicando una ventana Blackman, en la figura (14.7) del fenmeno
Gibbs se ve de la siguiente forma:



Figura 14-16

La ventana Blackman ofrece una banda de transicin igual a la siguiente relacin: dW = 11/M

Una ventana Blackman se representa por medio de la siguiente funcin w(n):



Figura 14-17

La respuest espectral de la ventana Blackman en escala logartmica es la siguiente:



Figura 14-18
202
La ventana Blackman ofrece una atenuacin del fenmeno Gibbs de -57dB.
14.5 Ejemplos de diseo para filtros FIR
En la siguiente seccin se mostrarn ejemplos de diseo para filtros FIR, implementando un
microcontrolador 18F452, con una fuente de 40MHz como reloj. Para fines prcticos reales la
frecuencia de 40MHz, se logra utilizando un cristal de 10MHz, y activando la fuente de reloj HS-
PLL en el PIC. Est opcin implementa internamente en el PIC, un PLL que multiplica la
frecuencia externa por un factor de cuatro, y el resultado es usado como fuente de reloj para el
procesador del microcontrolador. Para todos los ejemplos FIR que se mostrarn se deben simular
con el mismo arreglo en ISIS, para este fin se implementa un circuito con los dispositivos
18F452, RES, OSCILLOSCOPE, Generador virtual Seno.

Para usar los generadores de seal virtual en ISIS, se debe picar en la barra de herramientas de la
izquierda el icono de Generator Mode, este tiene la siguiente apariencia visual: , dentro de este
se escoge la opcin SINE, y se pega dentro del rea de trabajo. Este generador tiene por defecto
una frecuencia de 1Hz, y una amplitud de 1 voltio. La adquisicin de seales se hace en el
microcontrolador por medio del mdulo AD, los niveles de tensin que las entradas anlogas
admiten, no pueden salirse de los confines de la polarizacin del microcontrolador. En otras
palabras los niveles de las entradas anlogas no pueden ser superiores a 5 voltios, ni voltajes
negativos. Para evitar las circunstancias antes nombradas, se debe manipular la configuracin del
generador virtual de seal, para este propsito, se hace doble clic, sobre el generador y se editan
los parmetros: Offset, y Amplitude. El parmetro offset se configura a 2,5 voltios, y el
parmetro Amplitude a 2 voltios. Est accin evita que las seales generadas se salgan de los
parmetros de PIC. Para fines de simulacin el parmetro Frequency, puede ser alterado al gusto
del desarrollador.

Una vista de est edicin se puede apreciar en la siguiente figura:


Figura 14-19
203

Indiferente al ejemplo que se simule en est seccin, se puede implementar el siguiente circuito
electrnico en ISIS:


Circuito 14-1

Para la reconstruccin de la seal procesada, se configuran 10 bits de salida, para hacer un
convertidor DA, por medio de un arreglo R-2R.

Para todos los ejemplos usados en este apartado, se usar la interrupcin por TIMER 0, para crear
el periodo de muestreo, y por defecto la frecuencia de muestreo.

El siguiente cdigo fuente muestra un ejemplo del muestreo de la seal por medio del TIMER 0:

//Declaracin de varales.
float x0, y0;
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Adquisicin de una muestra de 10 bits en, x[0].
x0 = (float)(ADC_Read(0)-512.0);
//
//Espacio para procesar la seal.
//
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(x0+512);
PORTC = (YY>>8)&3;
PORTB = YY&255;
204
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}
14.5.1 Ejemplo de diseo para filtro pasa bajas
Fs = 1291,32KHz.
Fc = 150Hz.
Ventana Rectangular.

Se determina la frecuencia de corte digital:
Wc = 2 Fc / Fs = 2 150 / 1291,32 = 0,72985.

Usando la formula (14.7), se designan los coeficientes de la funcin h(n):

h(-8)=-0.0171035387965417
h(-7)=-0.0419431579233366
h(-6)=-0.0501329294124475
h(-5)=-0.0309497847516785
h(-4)=0.0175345019583181
h(-3)=0.0864308262744764
h(-2)=0.158173992108178
h(-1)=0.212237065988464
h(0)=0.232320416318186
h(1)=0.212237065988464
h(2)=0.158173992108178
h(3)=0.0864308262744764
h(4)=0.0175345019583181
h(5)=-0.0309497847516785
h(6)=-0.0501329294124475
h(7)=-0.0419431579233366
h(8)=-0.0171035387965417


205
Se debe tener presente que para fines de programacin los valores de n no pueden ser negativos,
por est razn se debe iniciar el vector en 0, y para usarlo en el cdigo en lenguaje C, se
implementa de la siguiente manera:

const float h[]=
{
-0.0171035387965417, //h(0)
-0.0419431579233366, //h(1)
-0.0501329294124475, //h(2)
-0.0309497847516785, //h(3)
0.0175345019583181, //h(4)
0.0864308262744764, //h(5)
0.158173992108178, //h(6)
0.212237065988464, //h(7)
0.232320416318186, //h(8)
0.212237065988464, //h(9)
0.158173992108178, //h(10)
0.0864308262744764, //h(11)
0.0175345019583181, //h(12)
-0.0309497847516785, //h(13)
-0.0501329294124475, //h(14)
-0.0419431579233366, //h(15)
-0.0171035387965417 //h(16)
};

El programa definitivo con la funcin de transferencia h(n), ser de la siguiente forma:

#define M 17
//Funcin de trasferencia h[n]
const float h[]=
{
-0.0171035387965417, //h(0)
-0.0419431579233366, //h(1)
-0.0501329294124475, //h(2)
-0.0309497847516785, //h(3)
0.0175345019583181, //h(4)
0.0864308262744764, //h(5)
0.158173992108178, //h(6)
0.212237065988464, //h(7)
0.232320416318186, //h(8)
0.212237065988464, //h(9)
0.158173992108178, //h(10)
0.0864308262744764, //h(11)
0.0175345019583181, //h(12)
-0.0309497847516785, //h(13)
-0.0501329294124475, //h(14)
-0.0419431579233366, //h(15)
-0.0171035387965417 //h(16)
};
206
//Declaracin de varales.
float x0, y0;
float x[M];
unsigned int YY;
unsigned short i;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
PORTC.F7=1;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Corrimiento continuo de la seal x[n]
for( i=M-1; i!=0; i-- )x[i]=x[i-1];
//Adquisicin de una muestra de 10 bits en, x[0].
x[0] = (float)(ADC_Read(0)-512.0);
//Convolucin contina.
y0 = 0.0; for( i=0; i<M; i++ ) y0 += h[i]*x[i];
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
PORTC.F7=0;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}


Por limitaciones de velocidad en este microcontrolador, y teniendo presente la frecuencia de
muestreo de 1291,32Hz no es posible usar un orden del filtro superior a 17. Sin embargo es
posible usar rdenes menores como; 15, 13, 11, 9, 7, 5, o 3. Para fines prcticos y didcticos en
los prximos ejemplos se implementarn filtros de orden 17 igual a este.
207
14.5.2 Ejemplo de diseo para filtro pasa altas
Fs = 1291,32KHz.
Fc = 200Hz.
Ventana Hamming.

Se determina la frecuencia de corte digital:
Wc = 2 Fc / Fs = 2 200 / 1291,32 = 0,97314.

Usando la formula (14.8), se definen los coeficientes de la funcin h(n) multiplicados por la
ventana Hamming w(n) de la ecuacin (14.12), dando como resultado la siguiente funcin h(n):

h(-8)=0
h(-7)=-0.000774581987451374
h(-6)=0.00297591407324525
h(-5)=0.0174357425540551
h(-4)=0.0246447931670207
h(-3)=-0.0148886974624375
h(-2)=-0.118648252092459
h(-1)=-0.243426834227261
h(0)=0.684363125797732
h(1)=-0.260893089082499
h(2)=-0.136977589378571
h(3)=-0.0187342667800403
h(4)=0.0345797805794857
h(5)=0.028555061237806
h(6)=0.00631989035694063
h(7)=-0.00299371636029323
h(8)=-0.00134023946307802

La implementacin del cdigo fuente es igual al filtro pasa bajas, sustituyendo el arreglo h[], por
el siguiente:

const float h[]=
{
0, //h(0)
-0.000774581987451374, //h(1)
0.00297591407324525, //h(2)
0.0174357425540551, //h(3)
0.0246447931670207, //h(4)
-0.0148886974624375, //h(5)
-0.118648252092459, //h(6)
-0.243426834227261, //h(7)
0.684363125797732, //h(8)
-0.260893089082499, //h(9)
-0.136977589378571, //h(10)
-0.0187342667800403, //h(11)
0.0345797805794857, //h(12)
0.028555061237806, //h(13)
208
0.00631989035694063, //h(14)
-0.00299371636029323, //h(15)
-0.00134023946307802 //h(16)
};
14.5.3 Ejemplo de diseo para filtro pasa banda
Fs = 1291,32KHz.
Fc1 = 150Hz.
Fc2 = 400Hz.
Ventana Hanning.

Se determinan las frecuencias de corte digital:
Wc1 = 2 Fc / Fs = 2 150 / 1291,32 = 0,72985.
Wc2 = 2 Fc / Fs = 2 400 / 1291,32 = 1,94628.

Usando la formula (14.9), se definen los coeficientes de la funcin h(n) multiplicados por la
ventana Hanning w(n) de la ecuacin (14.13), dando como resultado la siguiente funcin h(n):

h(-8)=0.0018052104538582
h(-7)=0.00905810215732946
h(-6)=0.00179096961917994
h(-5)=0.00393014193876244
h(-4)=0.0307760790492056
h(-3)=-0.0879236273273945
h(-2)=-0.218010454414228
h(-1)=0.078115497545518
h(0)=0.384167993159943
h(1)=0.0832388331308223
h(2)=-0.248392736747743
h(3)=-0.107904878578323
h(4)=0.0411879382357919
h(5)=0.00583790841302624
h(6)=0.00299868100666665
h(7)=0.0163162389068139
h(8)=0.00250614601893693

La funcin h[], para implementar en el cdigo fuente en lenguaje C es:

const float h[]=
{
0.0018052104538582, //h(0)
0.00905810215732946, //h(1)
0.00179096961917994, //h(2)
0.00393014193876244, //h(3)
0.0307760790492056, //h(4)
-0.0879236273273945, //h(5)
-0.218010454414228, //h(6)
0.078115497545518, //h(7)
209
0.384167993159943, //h(8)
0.0832388331308223, //h(9)
-0.248392736747743, //h(10)
-0.107904878578323, //h(11)
0.0411879382357919, //h(12)
0.00583790841302624, //h(13)
0.00299868100666665, //h(14)
0.0163162389068139, //h(15)
0.00250614601893693 //h(16)
};
14.5.4 Ejemplo de diseo para filtro rechaza banda
Fs = 1291,32KHz.
Fc1 = 150Hz.
Fc2 = 400Hz.
Ventana Blackman.

Se determinan las frecuencias de corte digital:
Wc1 = 2 Fc / Fs = 2 150 / 1291,32 = 0,72985.
Wc2 = 2 Fc / Fs = 2 400 / 1291,32 = 1,94628.

Usando la formula (14.10), se definen los coeficientes de la funcin h(n) multiplicados por la
ventana Blackman w(n) de la ecuacin (14.14), dando como resultado la siguiente funcin h(n):

h(-8)=3.13154095338657E-19
h(-7)=-0.00105084724932717
h(-6)=-0.000518135020348656
h(-5)=-0.00174730211401576
h(-4)=-0.0182611591144528
h(-3)=0.0645431455464317
h(-2)=0.186587834540544
h(-1)=-0.0738928265716166
h(0)=0.604271792109402
h(1)=-0.0827284691705043
h(2)=0.234965429330525
h(3)=0.0923521657912548
h(4)=-0.0302353209611255
h(5)=-0.00346395569934133
h(6)=-0.00133318382487159
h(7)=-0.00472035632958784
h(8)=-0.000290742652784183

La funcin h[], para implementar en el cdigo fuente en lenguaje C es:

const float h[]=
{
3.13154095338657E-19, //h(0)
-0.00105084724932717, //h(1)
210
-0.000518135020348656, //h(2)
-0.00174730211401576, //h(3)
-0.0182611591144528, //h(4)
0.0645431455464317, //h(5)
0.186587834540544, //h(6)
-0.0738928265716166, //h(7)
0.604271792109402, //h(8)
-0.0827284691705043, //h(9)
0.234965429330525, //h(10)
0.0923521657912548, //h(11)
-0.0302353209611255, //h(12)
-0.00346395569934133, //h(13)
-0.00133318382487159, //h(14)
-0.00472035632958784, //h(15)
-0.000290742652784183 //h(16)
};
14.5.5 Ejemplo de diseo para filtro multi banda
Fs = 1291,32KHz.
Fc1 = 161Hz.
Fc2 = 322Hz.
Fc3 = 484Hz.
Fc4 = 645.66Hz.
A1 = 1.
A2 = 0,5.
A3 = 0,2.
A4 = 1.
Ventana Rectangular.

Se determinan las frecuencias de corte digital:
Wc1 = 2 Fc1 / Fs = 2 161 / 1291,32 = 0,78337.
Wc2 = 2 Fc2 / Fs = 2 322 / 1291,32 = 1,56675.
Wc3 = 2 Fc3 / Fs = 2 484 / 1291,32 = 2,355.
Wc4 = 2 Fc4 / Fs = 2 645,66 / 1291,32 = .

Usando la formula (14.11), se definen los coeficientes de la funcin h(n):

h(-8)=-0.000403386658426763
h(-7)=-0.00443133542115946
h(-6)=-0.0685784954060509
h(-5)=0.0330418473673128
h(-4)=-0.000367826230314909
h(-3)=-0.0538949660023408
h(-2)=0.207286062892996
h(-1)=0.0275264614524777
h(0)=0.674596536876994
h(1)=0.0275264614524777
h(2)=0.207286062892996
211
h(3)=-0.0538949660023408
h(4)=-0.000367826230314909
h(5)=0.0330418473673128
h(6)=-0.0685784954060509
h(7)=-0.00443133542115946
h(8)=-0.000403386658426763

La funcin h[], para implementar en el cdigo fuente en lenguaje C es la siguiente:

const float h[]=
{
-0.000403386658426763, //h(0)
-0.00443133542115946, //h(1)
-0.0685784954060509, //h(2)
0.0330418473673128, //h(3)
-0.000367826230314909, //h(4)
-0.0538949660023408, //h(5)
0.207286062892996, //h(6)
0.0275264614524777, //h(7)
0.674596536876994, //h(8)
0.0275264614524777, //h(9)
0.207286062892996, //h(10)
-0.0538949660023408, //h(11)
-0.000367826230314909, //h(12)
0.0330418473673128, //h(13)
-0.0685784954060509, //h(14)
-0.00443133542115946, //h(15)
-0.000403386658426763, //h(16)
};

212
14.6 Filtros IIR
Los filtros IIR, son de implementacin computacional ms simple, pero su diseo y sus clculos
son de mayor complejidad. Para disear un filtro IIR, existen diferentes tcnicas, sin embargo
este captulo se centrar en el diseo por medio de la transformacin bilineal. La transformacin
bilineal es una relacin que existe entre la variable compleja s, y z. Esto quiere decir que para
realizar un filtro IIR, se requiere una funcin de transferencia en trminos de la variable s. En
sntesis para iniciar el diseo de un filtro IIR, se requiere como punto de partida, la funcin de
transferencia de un filtro anlogo. Para fines de estudio en este captulo se mostrarn a
continuacin las funciones de transferencia de los filtros bsicos de segundo orden:

Filtro Pasa Bajas:
2 2
2
2
) (
c c
c
s s
s H
O + O +
O
=
,
Ecuacin 14-15
Filtro Pasa Altas:
2 2
2
2
) (
c c
s s
s
s H
O + O +
=
,
Ecuacin 14-16

Filtro Pasa Banda:
2
0
2
) (
O + O +
O
=
s s
s
s H
B
B
Ecuacin 14-17


Filtro Rechaza Banda:
2
0
2
2
0
2
) (
O + O +
O +
=
s s
s
s H
B
Ecuacin 14-18

Las frecuencias estn definidas en radianes/segundo. Las frecuencias c representan la
frecuencia de corte en los filtros pasa bajas, y altas. Las frecuencias o representan la frecuencia
de resonancia en los filtros pasa banda y rechaza banda. Las frecuencias B representan el ancho
de banda de los filtros pasa banda y rechaza banda. El coeficiente , , representa el
amortiguamiento del filtro, el valor que este coeficiente debe tomar es mayor que 0, cuando el
coeficiente de amortiguamiento vale 0, el filtro se convierte en resonante, y tendra un
comportamiento similar a los filtros pasa banda o rechaza banda. Por otra parte el coeficiente de
amortiguamiento no podr ser negativo, esto generara una funcin de transferencia inestable.
Cabe denotar que la implementacin de filtros IIR, produce en la respuesta de la seal
distorsiones mayores a las que se generan con los filtros FIR.
213
14.6.1 Transformacin bilineal
La transformacin bilineal es una relacin matemtica entre las variables complejas s, y z. Est
relacin se rige por las siguientes ecuaciones:
) 1 (
) 1 ( 2
) 1 (
) 1 ( 2
1
1
1
1

=
+

=
z
z F
z T
z
s
s
s
Ecuacin 14-19
En la ecuacin (14.19), se puede observar la relacin entre las dos variables, donde Ts, y Fs, son
respectivamente el periodo de muestreo y frecuencia de muestreo implementado. De la misma
forma existe una relacin entre las frecuencias del filtro anlogo y el filtro digital, est relacin se
puede apreciar en la siguiente ecuacin:
)
2
tan( 2
)
2
tan( 2
d
s
s
d
w
F
T
w
= = O
Ecuacin 14-20
Donde la frecuencia digital es: Wd, la frecuencia anloga es: , y Ts, Fs, son respectivamente el
periodo de muestreo y la frecuencia de muestreo.

De la misma forma que en los filtros FIR, la relacin entre la frecuencia digital y la frecuencia en
hercios es la siguiente:
) tan( 2
) tan( 2
2
s
x
s
s
s
x
x
s
x
d
F
F
F
T
F
F
F
F
w
t
t
t
= = O =
Ecuacin 14-21
Para contextualizar este proceso, se mostrar a continuacin la transformacin bilineal de los
cuatro filtros bsicos en segundo orden.
14.6.2 Filtro Pasa Bajas IIR
Como primera medida, se realiza el reemplazo de variables en la ecuacin (14.15), para obtener
la funcin h(z):
2
1
1
2
1
1
2
) 1 (
) 1 ( 2
2
) 1 (
) 1 ( 2
) (
c
s
c
s
c
z
z F
z
z F
z H
O +
(

O +
(

O
=

,


2 1 2 1 1 2 1 2
2 1 2
) 1 ( ) 1 )( 1 ( 4 ) 1 ( 4
) 1 (
) (

+ O + + O +
+ O
=
z z z F z F
z
z H
c s c s
c
,


) 2 1 ( ) 1 ( 4 ) 2 1 ( 4
) 2 1 (
) (
2 1 2 2 2 1 2
2 1 2


+ + O + O + +
+ + O
=
z z z F z z F
z z
z H
c s c s
c
,


2 2 2 1 2 2 2 2
2 2 1 2 2
] 4 4 [ ] 8 2 [ ] 4 4 [
2
) (


O + O + O + O + O +
O + O + O
=
z F F z F F F
z z
z H
c s c s s c c s c s
c c c
, ,

214
En este punto se tiene una funcin de transferencia con polinomios ordenados en los polos y los
ceros, de la forma H(z) = A(z)/B(z). Para los polinomios A, B, se tiene en este caso expresiones
de segundo orden con la forma:
2
3
1
2
0
1
) (

+ + = z a z a z a z A ,
2
3
1
2
0
1
) (

+ + = z b z b z b z B .
Despus de tener la funcin de transferencia de esta forma se debe implementar una ecuacin en
diferencias para la ejecucin en la programacin, para deducir la ecuacin en diferencias es
necesario forzar el coeficiente del denominador b1 a valer 1. Para lograr este objetivo todos los
coeficientes a y b se dividen en b1. Est condicin aplicada en la ltima ecuacin del filtro pasa
bajas, da como resultado lo siguiente:

2
2 2
2 2
1
2 2
2 2
2
2 2
2
1
2 2
2
2 2
2
] 4 4 [
] 4 4 [
] 4 4 [
] 8 2 [
1
] 4 4 [ ] 4 4 [
2
] 4 4 [
) (


O + O +
O + O
+
O + O +
O
+
O + O +
O
+
O + O +
O
+
O + O +
O
=
z
F F
F F
z
F F
F
z
F F
z
F F F F
z H
c s c s
c s c s
c s c s
s c
c s c s
c
c s c s
c
c s c s
c
,
,
,
, , ,


La misma ecuacin en trminos de los coeficientes, es de la siguiente forma:

2 2
2 2
3
2 2
2 2
2
1
1 3
1 2
2 2
2
1
2
3
1
2
0
1
2
3
1
2
0
1
4 4
4 4
4 4
8 2
1
2
4 4
, ) (
c s c s
c s c s
c s c s
s c
c s c s
c
F F
F F
b
F F
F
b
b
a a
a a
F F
a
z b z b z b
z a z a z a
z H
O + O +
O + O
=
O + O +
O
=
=
=
=
O + O +
O
=
+ +
+ +
=


,
,
,
,


Para realizar la ecuacin en diferencias se hace la siguiente transformacin de z a n.

) ( * ) ( ) ( * ) ( ) ( ) ( ) ( ) (
) (
) (
) (
) (
) ( n a n x n b n y z A z X z B z Y
z B
z A
z X
z Y
z H = = = =

Realizando la transformacin inversa de z, se tiene una doble convolucin, que genera una
ecuacin de la siguiente forma:
) 2 ( ) 1 ( ) ( ) 2 ( ) 1 ( ) (
2 2 1 3 2 1
+ + = + + n x a n x a n x a n y b n y b n y b


En conclusin la salida y(n) queda de la siguiente manera:
) 2 ( ) 1 ( ) 2 ( ) 1 ( ) ( ) (
3 2 2 2 1
+ + = n y b n y b n x a n x a n x a n y
215
14.6.3 Ejemplo de diseo para filtro pasa bajas
Fs = 1291.32Hz.
Fc = 100Hz.
2
2
= , .
Para el caso particular de los filtros pasa bajas, y pasa altas de segundo orden el valor de , debe
ser
2
2 para que la frecuencia de corte no sufra desplazamientos con respecto a las condiciones
establecidas para los filtros en general.

Para deducir la frecuencia de corte anloga en funcin de las frecuencias reales se usa la ecuacin
(14.21), dando como resultado la siguiente frecuencia de corte:

0154 . 641 )
32 , 1291
100
tan( ) 32 , 1291 ( 2 ) tan( 2 = = = O
t t
s
c
s c
F
F
F

El paso siguiente es remplazar las constantes en las relaciones que determinan los coeficientes a,
y b. Este paso se puede apreciar a continuacin:

6363549 0,50294954
) 0154 , 641 ( ) 32 , 1291 )( 0154 , 641 )(
2
2
( 4 ) 32 , 1291 ( 4
) 0154 , 641 ( ) 32 , 1291 )( 0154 , 641 )(
2
2
( 4 ) 32 , 1291 ( 4
4 4
4 4
0532316 -1,3284348
) 0154 , 641 ( ) 32 , 1291 )( 0154 , 641 )(
2
2
( 4 ) 32 , 1291 ( 4
) 32 , 1291 ( 8 ) 0154 , 641 ( 2
4 4
8 2
1
52600961 0,04362868
05201923 0,08725737 2
52600961 0,04362868
) 0154 , 641 ( ) 32 , 1291 )( 0154 , 641 )(
2
2
( 4 ) 32 , 1291 ( 4
) 154 , 641 (
4 4
, ) (
2 2
2 2
2 2
2 2
3
2 2
2 2
2 2
2 2
2
1
1 3
1 2
2 2
2
2 2
2
1
2
3
1
2
0
1
2
3
1
2
0
1
=
+ +
+
=
O + O +
O + O
=
=
+ +

=
O + O +
O
=
=
= =
= =
=
+ +
=
O + O +
O
=
+ +
+ +
=


c s c s
c s c s
c s c s
s c
c s c s
c
F F
F F
b
F F
F
b
b
a a
a a
F F
a
z b z b z b
z a z a z a
z H
,
,
,
,


La implementacin de un filtro IIR, de orden N, requiere un bfer de datos igual a: 2(N+1). En el
caso de un filtro de segundo orden se requieren 3 campos para guardar los ltimos valores de la
entrada x, y 3 campos ms para los 3 ltimos valores de la salida y. Para ilustrar la
implementacin de este proceso se usar la misma arquitectura de software y hardware
implementada en los filtros FIR. A continuacin se puede observar el siguiente ejemplo en
lenguaje C:

//Declaracin de varales.
float x0=0, x1=0, x2=0, y0=0, y1=0, y2=0;
216
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Adquisicin de una muestra de 10 bits en, x[0].
x0 = (float)(ADC_Read(0)-512.0);
//Implementacin de la ecuacin en diferencias.
y0 = (x0+x2)*0.0436286852600961 + x1*0.0872573705201923 + y1*1.32843480532316
-y2*0.502949546363549;
//Corrimiento de los valores x(n), y y(n).
y2 = y1;
y1 = y0;
x2 = x1;
x1 = x0;
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}

14.6.4 Filtro Pasa Altas IIR
De la misma forma que se hizo en el filtro pasa bajas, se realiza el reemplazo de variable en la
ecuacin (14.16), para obtener la funcin h(z):

217
2
1
1
2
1
1
2
1
1
) 1 (
) 1 ( 2
2
) 1 (
) 1 ( 2
) 1 (
) 1 ( 2
) (
c
s
c
s
s
z
z F
z
z F
z
z F
z H
O +
(

O +
(

,


2 1 2 1 1 2 1 2
2 1 2
) 1 ( ) 1 )( 1 ( 4 ) 1 ( 4
) 1 ( 4
) (

+ O + + O +

=
z z z F z F
z F
z H
c s c s
s
,


) 2 1 ( ) 1 ( 4 ) 2 1 ( 4
) 2 1 ( 4
) (
2 1 2 2 2 1 2
2 1 2


+ + O + O + +
+
=
z z z F z z F
z z F
z H
c s c s
s
,


2 2 2 1 2 2 2 2
2 2 1 2 2
] 4 4 [ ] 8 2 [ ] 4 4 [
4 8 4
) (


O + O + O + O + O +
+
=
z F F z F F F
z F z F F
z H
c s c s s c c c s
s s s
, ,



Realizando la normalizacin de los coeficientes se obtiene lo siguiente:

2
2 2
2 2
1
2 2
2 2
2
2 2
2
1
2 2
2
2 2
2
4 4
4 4
4 4
8 2
1
4 4
4
4 4
8
4 4
4
) (


O + O +
O + O
+
O + O +
O
+
O + O +
+
O + O +

O + O +
=
z
F F
F F
z
F F
F
z
F F
F
z
F F
F
F F
F
z H
c s c s
c s c s
c s c s
s c
c s c s
s
c s c s
s
c s c s
s
,
,
,
, , ,


De est forma los coeficientes a, y b quedan definidos as:

2 2
2 2
3
2 2
2 2
2
1
1 3
1 2
2 2
2
1
2
3
1
2
0
1
2
3
1
2
0
1
4 4
4 4
4 4
8 2
1
2
4 4
4
, ) (
c s c s
c s c s
c s c s
s c
c s c s
s
F F
F F
b
F F
F
b
b
a a
a a
F F
F
a
z b z b z b
z a z a z a
z H
O + O +
O + O
=
O + O +
O
=
=
=
=
O + O +
=
+ +
+ +
=


,
,
,
,


14.6.5 Ejemplo de diseo para filtro pasa altas
Fs = 1291.32Hz.
Fc = 200Hz.
218
2
2
= , .

Se determina la frecuencia de corte anloga en trminos de la frecuencia digital:

19404 , 1366 )
32 , 1291
200
tan( ) 32 , 1291 ( 2 ) tan( 2 = = = O
t t
s
c
s c
F
F
F

Seguidamente se determinan los coeficientes del filtro:

7215126 0,26212340
) 19404 , 1366 ( ) 32 , 1291 )( 19404 , 1366 )(
2
2
( 4 ) 32 , 1291 ( 4
) 19404 , 1366 ( ) 32 , 1291 )( 19404 , 1366 )(
2
2
( 4 ) 32 , 1291 ( 4
4 4
4 4
43923452 -0,7099519
) 19404 , 1366 ( ) 32 , 1291 )( 19404 , 1366 )(
2
2
( 4 ) 32 , 1291 ( 4
) 32 , 1291 ( 8 ) 19404 , 1366 ( 2
4 4
8 2
1
7784645 0,49301883
75569289 -0,9860376 2
7784645 0,49301883
) 19404 , 1366 ( ) 32 , 1291 )( 19404 , 1366 )(
2
2
( 4 ) 32 , 1291 ( 4
) 32 , 1291 ( 4
4 4
4
, ) (
2 2
2 2
2 2
2 2
3
2 2
2 2
2 2
2 2
2
1
1 3
1 2
2 2
2
2 2
2
1
2
3
1
2
0
1
2
3
1
2
0
1
=
+ +
+
=
O + O +
O + O
=
=
+ +

=
O + O +
O
=
=
= =
= =
=
+ +
=
O + O +
=
+ +
+ +
=


c s c s
c s c s
c s c s
s c
c s c s
s
F F
F F
b
F F
F
b
b
a a
a a
F F
F
a
z b z b z b
z a z a z a
z H
,
,
,
,


La programacin de este filtro pasa altas, bajo las mismas condiciones del filtro pasa bajas es el
siguiente:

//Declaracin de varales.
float x0=0, x1=0, x2=0, y0=0, y1=0, y2=0;
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Adquisicin de una muestra de 10 bits en, x[0].
x0 = (float)(ADC_Read(0)-512.0);
//Implementacin de la ecuacin en diferencias.
y0 = (x0+x2)*0.493018837784645 - x1*0.986037675569289 +
y1*0.709951943923452 - y2*0.262123407215126;
//Corrimiento de los valores x(n), y y(n).
219
y2 = y1;
y1 = y0;
x2 = x1;
x1 = x0;
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}

14.6.6 Filtro Pasa Banda IIR
Para la funcin de transferencia h(z) en el filtro pasa banda se realiza el cambio de variable
bilineal, tomando como base la ecuacin (14.17):

2
0 1
1
2
1
1
1
1
) 1 (
) 1 (
2
) 1 (
) 1 (
2
) 1 (
) 1 (
2
) (
O +
(

O +
(

O
(

z
z
F
z
z
F
z
z
F
z H
s B s
B s


2 1 2
0
1 1 2 1 2
1 1
) 1 ( ) 1 )( 1 ( 2 ) 1 ( 4
) 1 )( 1 ( 2
) (


+ O + + O +
+ O
=
z z z F z F
z z F
z H
B s s
B s


) 2 1 ( ) 1 ( 2 ) 2 1 ( 4
) 1 ( 2
) (
2 1 2
0
2 2 1 2
2

+ + O + O + +
O
=
z z z F z z F
z F
z H
B s s
B s


2 2
0
2 1 2
0
2
0
2
2
] 2 4 [ ] 2 2 [ ] 2 4 [
2 2
) (

O + O + O O + O + O +
O O
=
z F F z F F F
z F F
z H
B s s B s B s s
B s B s

220
Normalizando la ecuacin se obtiene la siguiente relacin:

2
2
0
2
2
0
2
1
2
0
2
2
0
2
2
0
2 2
0
2
2 4
2 4
2 4
2 2
1
2 4
2
2 4
2
) (

O + O +
O + O
+
O + O +
O O
+
O + O +
O

O + O +
O
=
z
F F
F F
z
F F
F
z
F F
F
F F
F
z H
B s s
B s s
B s s
B s
B s s
B s
B s s
B s


De la anterior ecuacin, se pueden estblecer las siguientes constantes:

2
0
2
2
0
2
3
2
0
2
2
0
2
1
1 3
2
2
0
2 1
2
3
1
2
0
1
2
3
1
2
0
1
2 4
2 4
2 4
2 2
1
0
2 4
2
, ) (
O + O +
O + O
=
O + O +
O O
=
=
=
=
O + O +
O
=
+ +
+ +
=


B s s
B s s
B s s
B s
B s s
B s
F F
F F
b
F F
F
b
b
a a
a
F F
F
a
z b z b z b
z a z a z a
z H


14.6.7 Ejemplo de diseo para filtro pasa banda
Fs = 1291.32Hz.
Fo = 300Hz.
Fb = 10Hz.

A continuacin se determinan las frecuencias anlogas para el diseo del filtro pasa banda:

58 , 2310 )
32 , 1291
300
tan( ) 32 , 1291 ( 2 ) tan( 2
0
0
= = = O
t t
s
s
F
F
F
8442 , 62 )
32 , 1291
10
tan( ) 32 , 1291 ( 2 ) tan( 2 = = = O
t t
s
b
s B
F
F
F

Posteriormente se determinan los coeficientes del filtro:

221
1725574 0.97332963
) 58 , 2310 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 58 , 2310 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
2 4
2 4
04098491 -0.2187550
) 58 , 2310 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 8442 , 62 )( 32 , 1291 ( 2 ) 58 , 2310 ( 2
2 4
2 2
1
841372129 -0.0133351
0
41372129 0.01333518
) 58 , 2310 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 8442 , 62 )( 32 , 1291 ( 2
2 4
2
, ) (
2 2
2 2
2
0
2
2
0
2
3
2 2
2
2
0
2
2
0
2
1
1 3
2
2 2 2
0
2 1
2
3
1
2
0
1
2
3
1
2
0
1
=
+ +
+
=
O + O +
O + O
=
=
+ +

=
O + O +
O O
=
=
= =
=
=
+ +
=
O + O +
O
=
+ +
+ +
=


B s s
B s s
B s s
B s
B s s
B s
F F
F F
b
F F
F
b
b
a a
a
F F
F
a
z b z b z b
z a z a z a
z H



14.6.8 Filtro Rechaza Banda IIR
Para la funcin de transferencia h(z) en el filtro pasa banda se realiza el cambio de variable
bilineal, tomando como base la ecuacin (14.17):


2
0 1
1
2
1
1
2
0
2
1
1
) 1 (
) 1 (
2
) 1 (
) 1 (
2
) 1 (
) 1 (
2
) (
O +
(

O +
(

O +
(

z
z
F
z
z
F
z
z
F
z H
s B s
s


2 1 2
0
1 1 2 1 2
2 1 2
0
2 1 2
) 1 ( ) 1 )( 1 ( 2 ) 1 ( 4
) 1 ( ) 1 ( 4
) (


+ O + + O +
+ O +
=
z z z F z F
z z F
z H
B s s
s


) 2 1 ( ) 1 ( 2 ) 2 1 ( 4
) 2 1 ( ) 2 1 ( 4
) (
2 1 2
0
2 2 1 2
2 1 2
0
2 1 2


+ + O + O + +
+ + O + +
=
z z z F z z F
z z z z F
z H
B s s
s


2 2
0
2 1 2 2
0
2
0
2
2 2
0
2 1 2 2
0
2
0
2
] 2 4 [ ] 8 2 [ ] 2 4 [
] 4 [ ] 8 2 [ ] 4 [
) (


O + O + O + O + O +
O + + O + O +
=
z F F z F F F
z F z F F
z H
B s s s B s s
s s s


Normalizando la ecuacin se obtiene la siguiente relacin:

2
2
0
2
2
0
2
1
2
0
2
2 2
0
2
2
0
2
2
0
2
1
2
0
2
2 2
0
2
0
2
2
0
2
2 4
2 4
2 4
8 2
1
2 4
4
2 4
8 2
2 4
4
) (


O + O +
O + O
+
O + O +
O
+
O + O +
O +
+
O + O +
O
+
O + O +
O +
=
z
F F
F F
z
F F
F
z
F F
F
z
F F
F
F F
F
z H
B s s
B s s
B s s
s
B s s
s
B s s
s
B s s
s


De la anterior ecuacin, se pueden estblecer las siguientes constantes:
222
2
0
2
2
0
2
3
2
0
2
2 2
0
2
1
1 3
2
0
2
2 2
0
2
2
0
2
2
0
2
1
2
3
1
2
0
1
2
3
1
2
0
1
2 4
2 4
2 4
8 2
1
2 4
8 2
2 4
4
, ) (
O + O +
O + O
=
O + O +
O
=
=
=
O + O +
O
=
O + O +
O +
=
+ +
+ +
=


B s s
B s s
B s s
s
B s s
s
B s s
s
F F
F F
b
F F
F
b
b
a a
F F
F
a
F F
F
a
z b z b z b
z a z a z a
z H




14.6.9 Ejemplo de diseo filtro rechaza banda
Fs = 1291.32Hz.
Fo = 100Hz.
Fb = 10Hz.


A continuacin se determinan las frecuencias anlogas para el diseo del filtro rechaza banda:


015 , 641 )
32 , 1291
100
tan( ) 32 , 1291 ( 2 ) tan( 2
0
0
= = = O
t t
s
s
F
F
F


8442 , 62 )
32 , 1291
10
tan( ) 32 , 1291 ( 2 ) tan( 2 = = = O
t t
s
b
s B
F
F
F

Posteriormente se determinan los coeficientes del filtro:

, ) (
2
3
1
2
0
1
2
3
1
2
0
1


+ +
+ +
=
z b z b z b
z a z a z a
z H
223
901547 0.95518463
) 015 , 641 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 015 , 641 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
2 4
2 4
6958352 -1.7282689
1
9507735 0,97759231
6958352 -1.7282689
) 015 , 641 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 32 , 1291 ( 8 ) 015 , 641 ( 2
2 4
8 2
9507735 0,97759231
) 015 , 641 ( ) 8442 , 62 )( 32 , 1291 ( 2 ) 32 , 1291 ( 4
) 015 , 641 ( ) 32 , 1291 ( 4
2 4
4
2 2
2 2
2
0
2
2
0
2
3
2 2
1
1 3
2 2
2 2
2
0
2
2 2
0
2
2 2
2 2
2
0
2
2
0
2
1
=
+ +
+
=
O + O +
O + O
=
= =
=
= =
=
+ +

=
O + O +
O
=
=
+ +
+
=
O + O +
O +
=
B s s
B s s
B s s
s
B s s
s
F F
F F
b
a b
b
a a
F F
F
a
F F
F
a


El cdigo fuente en lenguaje C, correspondiente a este diseo es el siguiente:

//Declaracin de varales.
float x0=0, x1=0, x2=0, y0=0, y1=0, y2=0;
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Adquisicin de una muestra de 10 bits en, x[0].
x0 = (float)(ADC_Read(0)-512.0);
//Implementacin de la ecuacin en diferencias.
y0 = (x0+x2)*0.977592319507735 + (y1-x1)*1.72826896958352 - y2*0.95518463901547;
//Corrimiento de los valores x(n), y y(n).
y2 = y1;
y1 = y0;
x2 = x1;
x1 = x0;
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
224
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}
14.7 Osciladores digitales
Generar una seal seno de forma sinttica, implica usar una matriz de rotacin que incluye dos
valores de salida de la seal y dos valores pasados, de la misma. La forma general de est matriz
se puede apreciar a continuacin:

(

=
(

) 1 (
) 1 (
) (
) (
n x
n y
d c
b a
n x
n y


Los clculos de la matriz de rotacin, permiten crear osciladores de 2 salidas que pueden tener
amplitud equitativa o no y salida en cuadratura o no, as como el nmero de multiplicaciones
requeridas por iteracin. Estas condiciones se resumen en la siguiente tabla:

Propiedades de los osciladores recursivos
Oscilador
Multiplicaciones
por iteracin
Amplitud
equitativa
Salida en
cuadratura
Factores Matriz de rotacin
Doble
cuadrado
2 Si No k=2Cos()
(

0 1
1 k

De acople
en
cuadratura
estndar
4 Si Si k=sen()
(
(

2
2
1
1
k k
k k


Tabla 14-1

Para iniciar el diseo de un oscilador o generador digital se debe definir el valor de la constante k,
y por defecto, el valor del ngulo , este se define por medio de la siguiente ecuacin:

s
g
F
F t
u
2
=
Ecuacin 14-22


225
Donde Fg es la frecuencia en hercios de la seal que se desea generar, y Fs es la frecuencia de
muestreo en hercios. La implementacin de estos generadores siempre usa la misma forma de
operaciones matemticas, que es la siguiente:

) 1 ( ) 1 ( ) (
) 1 ( ) 1 ( ) (
+ =
+ =
n dx n cy n x
n bx n ay n y


Para que el oscilador arranque correctamente es importante dar valores iniciales a las salidas y1, y
y2. Por obvias razones los osciladores de mayor velocidad son los que solo requieren de una
multiplicacin por iteracin.
14.7.1 Ejemplo de diseo oscilador doble cuadrado
Fs = 1291,32Hz.
Fg = 100Hz.

El valor del ngulo , es el que se calcula a continuacin:

4865707421 , 0
32 , 1291
100 2
2
= = =
t
t
u
s
g
F
F


Con el valor se puede calcular el valor de k, que es el siguiente:

k=2Cos(0,4865707421) = 1,76788313

De est manera se tiene la siguiente matriz de rotacin:

(

0 1
1 1,76788313


Las ecuaciones de implementacin son las siguientes:

) 1 ( ) (
) 1 ( ) 1 ( 1,76788313 ) (
=
+ =
n y n x
n x n y n y


Las mismas funciones en trminos de solo la salida y es igual a la siguiente ecuacin:

) 2 ( ) 1 ( 1,76788313 ) ( + = n y n y n y

La condicin para el funcionamiento de este oscilador es que la magnitud de la seal debe ser 1.
Otra condicin para el funcionamiento adecuado de este oscilador es dar valores iniciales a las
salidas y(n-1), y y(n-2), las cuales se pueden iniciar de la siguiente forma:

y(n-1) = Cos(-) = Cos(-0,4865707421).
y(n-2) = Cos(-2 ) = Cos(-2(0,4865707421)).

Para manipular la amplitud se debe multiplicar la salida y(n), por el factor deseado.
226
Para fines de simulacin, se implementarn las mismas condiciones del hardware usado en los
filtros FIR, e IIR, omitiendo el generador de onda seno que se conecta a la entrada anloga.
Teniendo presente las anteriores observaciones se puede implementar el siguiente cdigo fuente
en lenguaje C, para simular este ejemplo:

//Declaracin de varales inicializadas.
float y0, y1=1.0, y2=0.883941565;
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Implementacin de la ecuacin del oscilador.
y0 = 1.76788313*y1 - y2;
//Se hace el corrimiento de la salida.
y2 = y1;
y1 = y0;
//Reconstruccin de la seal: y en 10 bits, amplificada 500 veces.
YY = (unsigned int)(500*y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}
14.7.2 Ejemplo de diseo para oscilador de acople en cuadratura
Fs = 1291,32Hz.
Fg = 150Hz.
A = 450.
227
Se calcula el ngulo de paso :

7298561132 , 0
32 , 1291
150 2
2
= = =
t
t
u
s
g
F
F


Posteriormente se calculan las constantes de la matriz:

. 6667624073 , 0 ) (
. 7452703484 , 0 )] 7298561132 , 0 ( [ 1 )] ( [ 1
2 2
= = =
= = = =
u
u
sen c b
sen sen d a


El patrn de la matriz de rotacin es el siguiente:

(

7452703484 , 0 6667624073 , 0
6667624073 , 0 7452703484 , 0


El juego de ecuaciones que rigen las iteraciones del oscilador son las siguientes:

) 1 ( 7452703484 , 0 ) 1 ( 6667624073 , 0 ) (
) 1 ( 6667624073 , 0 ) 1 ( 7452703484 , 0 ) (
+ =
+ =
n x n y n x
n x n y n y


Para dar inicio correcto al oscilador se deben dar valores iniciales a las salidas retardadas y(n-1),
y x(n-1), para este fin se debe tener presente que este oscilador tiene las dos salidas en cuadratura,
es decir que entre las dos salidas siempre existe un desfase de 90 grados. Bajo este concepto se
puede concluir que las dos seales en cuadratura tendrn la misma magnitud a 3/4, de est
manera se asignan los siguientes valores iniciales:

y(n-1) = x(n-1) = ASen(3/4),
y(n-1) = x(n-1) = 450Sen(3/4) = 318,1980515.

Finalmente se implementa, el cdigo fuente en lenguaje C, para este oscilador:

//Declaracin de varales inicializadas.
float y0, y1=318.1980515, x0, x1=318.1980515;
unsigned int YY;
//Declaracin de la funcin de interrupciones.
void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
//Implementacin de las ecuaciones del oscilador.
y0 = 0.7452703484*y1 + 0.6667624073*x1;
x0 = -0.6667624073*y1 + 0.7452703484*x1;
//Se hace el corrimiento de la salida.
228
y1 = y0;
x1 = x0;
//Reconstruccin de la seal: y en 10 bits.
YY = (unsigned int)(y0+512.0);
PORTC = (YY>>8)&3;
PORTB = YY&255;
INTCON.F2=0;
}
}

void main( void )
{
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
TRISC = 0;
PORTC = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
}
}
14.8 Transformada discreta de Fourier DFT
La transformacin de Fourier es un procedimiento matemtico que permite analizar las
componentes espectrales y la intensidad de potencia de una seal anloga, o discreta. Las
aplicaciones de este procedimiento son numerosas en las que se pueden nombrar: Analizadores
de espectro, reconocimiento de patrones, en seales, de comunicaciones, biomdicas, y audio,
entre otras. La transformada de Fourier, es una temtica sumamente densa, sin embargo este
captulo busca mostrar de forma simple la implementacin de est herramienta. La transformada
discreta de Fourier o DTF, est definida por la siguiente ecuacin:

=
1
0
) ( ) (
L
n
jwn
e n x jw X
Ecuacin 14-23

Como se puede apreciar en la anterior ecuacin la potencia de una frecuencia w, se puede evaluar
en un fragmento de seal de longitud L, de igual manera se puede notar que los valores
resultantes de la funcin X(jw), son nmeros complejos, por est razn los anlisis de Fourier se
hacen por excelencia en trminos de la magnitud de estos nmeros complejos. La ecuacin
(15.23) en trminos de un nmero complejo rectangular es la siguiente:

=
=
1
0
)] ( ) )[cos( ( ) (
L
n
wn jsen wn n x jw X
Ecuacin 14-24

229
De est forma la relacin X(jw), puede ser pasada a la magnitud de s misma como |X(jw)|, y su
relacin matemtica es la siguiente:

2
1
0
2
1
0
) ( ) ( ) cos( ) ( | ) ( |
(

+
(

=


=

=
L
n
L
n
wn sen n x wn n x jw X
Ecuacin 14-25

Est ecuacin matemtica permite evaluar la potencia, o la intensidad de la componente w, dentro
de la muestra x(n), de longitud L.

Un fragmento de cdigo en lenguaje C, que realice est operacin se puede implementar con una
funcin como la siguiente:

//Funcin para determinar la intensidad de potencia
//de la componente w, en la seal x_n.
float TDF( float *x_n, float w, unsigned int L )
{
//Declaracion de variables.
unsigned int n;
float R=0.0, I=0.0;
//Bucle for para realizar las sumatorias.
for( n=0; n<L; n++ )
{
//Clculo y sumatoria de los componentes
//reales e imaginarios.
R += cos( w*n );
I += sin( w*n );
}
//Se retorna el valor de la magnitud del
// nmero complejo.
return sqrt( R*R + I*I );
}

El siguiente ejemplo implementa un programa que permite detectar la presencia de tres
frecuencias diferentes en una seal anloga, por medio de la transformada de Fourier. Como
primera medida se definen las tres frecuencias anlogas y sus respectivas frecuencias digitales,
F1=100Hz, F2=200Hz, y F3=300Hz, la frecuencia de muestreo se define de 1291,32Hz, con el
fin de implementar la misma estructura del microcontrolador 18F452, que se us en los filtros
FIR, e IIR.

459712226 , 1
32 . 1291
300 2
9731414842 , 0
32 . 1291
200 2
1 4865770742 , 0
32 . 1291
100 2
3
2
1
= =
= =
= =
t
t
t
W
W
W

230
Para realizar la transformada de Fourier, se usar la funcin antes citada. Una salida del
microcontrolador se activa cuando se detecta la potencia suficiente de la componente espectral.
La seal es adquirida por una entrada anloga del PIC, la cual es la suma de tres fuentes
diferentes. El programa correspondiente para este ejercicio es el siguiente:

//Declaracin de varales inicializadas.
float x[64];
unsigned short i, OK=1;
//Declaracin de la funcin de interrupciones.

//Funcin para determinar la intensidad de potencia
//de la componente w, en la seal x_n.
float TDF( float *x_n, float w, unsigned int L )
{
//Declaracin de variables.
unsigned short n;
float R=0.0, I=0.0;
//Bucle for para realizar las sumatorias.
for( n=0; n<L; n++ )
{
//Clculo y sumatoria de los componentes
//reales e imaginarios.
R += x_n[n]*cos( w*n );
I += x_n[n]*sin( w*n );
}
//Se retorna el valor de la magnitud del
// nmero complejo.
return sqrt( R*R + I*I );
}

void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
if( OK ) //Se evala la adquisicin de muestras.
{
OK++; //Se cuentan las muestras tomadas.
//Se corren las ltimas 64 muestras en el bufer x.
for( i=63; i!=0; i-- )x[i]=x[i-1];
//Se guarda la ltima muestra.
x[0] = ((float)ADC_Read(0)-512.0);
}
INTCON.F2=0;
}
}

231
void main( void )
{
float RES1, RES2, RES3;
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
while(1)//Bucle infinito.
{
while( OK<65 );//Se espera a recibir 64 muestras.
OK =0; //Se suspenden la adquisicin de muestras.
//Se hace la transformada de Fourier, de la componente de 100Hz.
RES1 = TDF( x, 0.4865707421, 64 );
//Se hace la transformada de Fourier, de la componente de 200Hz.
RES2 = TDF( x, 0.9731414842, 64 );
//Se hace la transformada de Fourier, de la componente de 300Hz.
RES3 = TDF( x, 1.459712226, 64 );
OK=1; //Se activa la adquisicin de muestras.
//Se evala la potencia de la seal de 100Hz.
if( RES1>800 )PORTB.F2=1; else PORTB.F2=0;
//Se evalua la potencia de la seal de 200Hz.
if( RES2>800 )PORTB.F1=1; else PORTB.F1=0;
//Se evala la potencia de la seal de 300Hz.
if( RES3>800 )PORTB.F0=1; else PORTB.F0=0;
}
}

Para realizar la simulacin de este ejercicio se implementa en ISIS, los dispositivos: 18F452,
RES, CAP, OP1P, BUTTON, LED-RED, y generador virtual. El circuito correspondiente para
est simulacin es el siguiente:

Circuito 14-2
232
La transformada de Fourier, implica mltiples clculos matemticos, como sumas,
multiplicaciones y evaluaciones trigonomtricas. Estos procesos hacen lento el rendimiento de la
mquina de proceso. Por esta razn la ciencia de tratamiento de seales, se vio en la necesidad de
buscar tcnicas de realizar la transformada de Fourier de forma mucho ms eficiente, de este
esfuerzo, sale como resultado notable el algoritmo de transformacin rpida de Fourier, o FFT.
Este algoritmo se fundamenta en la divisin en segmentos cortos para realizar la evaluacin de la
transformada de Fourier.
14.8.1 Transformada rpida de Fourier FFT
La transformada rpida de Fourier, organiza en una matriz las muestras de entrada y realiza
trasformadas ms pequeas en las filas y posteriormente en las columnas. Las muestras
digitalizadas de la seal anloga se pueden representar de la siguiente forma:

x(0), x(1), x(2), x(3), x(4), x(5),.x(N)

Donde N es el nmero mximo de muestras que se desean analizar.

Las muestras son organizadas en una matriz de L filas, con M columnas. En la siguiente matriz se
puede apreciar el almacenamiento por columnas:

(
(
(
(

=
) 15 ( ) 11 ( ) 7 ( ) 3 (
) 14 ( ) 10 ( ) 6 ( ) 2 (
) 13 ( ) 9 ( ) 5 ( ) 1 (
) 12 ( ) 8 ( ) 4 ( ) 0 (
) , (
x x x x
x x x x
x x x x
x x x x
m l x


Seguidamente se debe realizar la transformacin por filas, haciendo la trasformada de M
muestras. Est operacin se realiza en funcin de la siguiente ecuacin:

| |
)
2
( )
2
cos(
) 1 ( 0
) 1 ( 0
) , ( ) , (
2
1
0
M
mq
jsen
M
mq
e W
M q
L l
W m l x q l F
M
mq
j
mq
M
M
m
mq
M
t t
t
= =
s s
s s
=

Ecuacin 14-26
La matriz F(l,q), es un arreglo de valores complejos correspondiente a las transformadas de M,
puntos sobre cada una de las filas. Seguidamente la matriz F(l,q), se multiplica por los factores de
fase Wn, est operacin se define en la siguiente ecuacin:

)
2
( )
2
cos(
) 1 ( 0
) 1 ( 0
) , ( ) , (
2
N
lq
jsen
N
lq
e W
M q
L l
q l F W q l G
N
lq
j
lq
N
lq
N
t t
t
= =
s s
s s
=

Ecuacin 14-27

233
Por ltimo se realiza la trasformada por columnas de L muestras. Est operacin se resume en la
siguiente ecuacin:
| |
)
2
( )
2
cos(
) 1 ( 0
) 1 ( 0
) , ( ) , (
2
1
0
L
lp
jsen
L
lp
e W
M q
L p
W q l G q p X
L
lp
j
lp
L
L
l
lp
L
t t
t
= =
s s
s s
=

Ecuacin 14-28

La matriz X(p,q), es la transformada final de las N muestras iniciales. Est matriz contiene en
cada uno de sus trminos un nmero complejo que representa la magnitud y la fase de las
componentes espectrales. La matriz X(p,q), se debe leer por filas, como se aprecia en la siguiente
matriz:
(
(
(
(

=
) 15 ( ) 14 ( ) 13 ( ) 12 (
) 11 ( ) 10 ( ) 9 ( ) 8 (
) 7 ( ) 6 ( ) 5 ( ) 4 (
) 3 ( ) 2 ( ) 1 ( ) 0 (
) , (
X X X X
X X X X
X X X X
X X X X
q p X


Cabe denotar que entre ms muestras se ingresen para hacer la transformacin, mayor ser la
resolucin en el espectro, pero a su vez mayor ser la cantidad de recursos de procesamiento y de
memoria requeridos. A continuacin se resume el proceso antes citado:

- Se archiva la seal de x(n), por columnas en la matriz x(l,m).
- Se calcula la transformada de M muestras de cada una de las filas.
- Se multiplican las anteriores transformadas por el factor de fase Wn.
- Se calcula la transformada de L muestras de cada una de las columnas.
- Se leen los datos de la matriz X(p,q), por filas.

El resultado de una transformada de Fourier, entrega un espectro evaluado de 0 a 2, lo que
significa que los valores superiores a , son un espejo de las componentes inferiores causadas por
los armnicos de las frecuencias inferiores a . En conclusin la lectura de la matriz solo se debe
hacer hasta la mitad, por ejemplo si la cantidad de muestras analizadas son 128, solo se deben
leer 64. De la misma manera la resolucin de la transformacin en hercios est definida por la
siguiente ecuacin:
N
F
R
s
Hz
=
Ecuacin 14-29

Donde R, es la resolucin en hercios, o el mnimo ancho de banda que se puede analizar con la
FFT. Fs es la frecuencia de muestreo, y N es el nmero de muestras ingresadas a la FFT.
Tambin cabe denotar que la primera muestra de la FFT, hace alusin a la componente espectral
ms baja incluida la frecuencia 0, o en otras palabras los niveles DC. Ests componentes son las
ms intensas, y para fines prcticos est primera muestra puede ser ignorada.

234
Para realizar un ejemplo con la FFT, se implementar el PIC 18F4585, dada su amplia memoria
RAM de 3328 Bytes, til para los procesos de la FFT. Sin embargo est capacidad de memoria
solo permite hacer una FFT, con mximo 169 muestras.

A continuacin se presentar un ejemplo en lenguaje C, para realizar la transformacin de una
seal de N = ML, muestras:

#define M 16
#define L 8
#define N L*M
#define PI 3.141592654

typedef struct
{
float R, I;
}Complejo;

//Declaracin de varales inicializadas.

unsigned short i, OK=0;
unsigned short Fi=0, Co=0;
//Declaracin de la funcin de interrupciones.

Complejo X[L][M];
Complejo Y[L][M];

//Funcin para realizar una multiplicacin compleja.
Complejo Producto( Complejo A, Complejo B )
{
Complejo Res;
Res.R = A.R*B.R - A.I*B.I;
Res.I = A.R*B.I + A.I*B.R;
return Res;
}

//Funcin para realizar una suma compleja.
Complejo Adicion( Complejo A, Complejo B )
{
Complejo Res;
Res.R = A.R + B.R;
Res.I = A.I + B.I;
return Res;
}

//Funcin para determinar la magnitud de un nmero complejo.
float Magnitud( Complejo A )
{
return sqrt( A.R*A.R + A.I*A.I );
}
235
//Clculo rpido de Fourier, de N muestras.
void FFT( void )
{
unsigned short l,q,m,p;
Complejo WW;

//Tro de bucles for, para ejecutar la
//ecuacin (15.26), la matriz Y[][], representa F(l,q).
for( l=0; l<L; l++ )
{
for( q=0; q<M; q++ )
{
Y[l][q].R = 0.0;
Y[l][q].I = 0.0;
for( m=0; m<M; m++ )
{
WW.R = cos( 2*PI*m*q / M );
WW.I = -sin( 2*PI*m*q / M );
WW = Producto( X[l][m], WW );
Y[l][q] = Adicion( Y[l][q], WW );
}
}
}


//Dupla se bucles for, para realizar la multiplicacin
//de factores Wn (15.27), Y[][] representa la matriz F(l,q), y
//X[][] representa la matriz G(l,q).
for( l=0; l<L; l++ )
{
for( q=0; q<M; q++ )
{
WW.R = cos( 2*PI*l*q / N );
WW.I = -sin( 2*PI*l*q / N );
X[l][q] = Producto( Y[l][q], WW );
}
}

//Tro de bucles for, para ejecutar la
//ecuacin (15.28), la matriz Y[][], representa X(p,q),
//y X[][] representa la matriz G(l,q).
for( p=0; p<L; p++ )
{
for( q=0; q<M; q++ )
{
Y[p][q].R=0.0;
Y[p][q].I=0.0;
for( l=0; l<L; l++ )
{
236
WW.R = cos( 2*PI*l*p / L );
WW.I = -sin( 2*PI*l*p / L );
WW = Producto( X[l][q], WW );
Y[p][q] = Adicion( Y[p][q], WW );
}
}
}

//Doble for anidado para determinar,
//la magnitud de la transformada,
//Este resultado queda en los trminos reales de X[][]
for( l=0; l<L; l++ )
for( m=0; m<M; m++ )
{
X[l][m].R = Magnitud( Y[l][m] );
X[l][m].I = 0.0;
}

}

void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
//Timer0 con periodo de 774,4u segundo.
// Fs = 1291,32 Hz.
if( OK ) //Se evala la adquisicin de muestras.
{
//Se hace la adquisicin de las muestras,
//y se archivan por columnas.
X[Fi][Co].R = ((float)ADC_Read(0)-127.0);
X[Fi][Co].I = 0.0;
Fi++;
if( Fi==L )
{
Fi = 0;
Co++;
if( Co==M )
{
Co=0;
OK=0;
}
}
}
INTCON.F2=0;
}
}

237
void main( void )
{
char Text[30];
unsigned short ff, cc, cont;
//Inicio del puerto B como salida.
TRISB = 0;
PORTB = 0;
//Se configura el TIMER 0, su interrupcin.
INTCON = 0b10100000;
T0CON = 0b11000101;
UART1_Init(9600);

while(1)//Bucle infinito.
{
OK = 1; //Se habilita la lectura de muestras.
UART1_Write_Text("// Adquisicion y FFT de:");
IntToStr( N, Text );
UART1_Write_Text(Text);
UART1_Write_Text(" Muestras //");
UART1_Write(13); UART1_Write(10);
while( OK ); //Se espera la adquisicion de las muestras.
FFT(); //Clculo de la FFT.
UART1_Write_Text("// Inicio de las muestras //");
UART1_Write(13); UART1_Write(10);
//La primera componente espectral se ignora y se hace igual a cero.
X[0][0].R = 0.0;
cont = 0;
//Se envan la magnitud de la FFT, hasta N/2
//por medio del puerto serial.
for( ff=0; ff<L; ff++ )
{
for( cc=0; cc<M; cc++ )
{
FloatToStr( X[ff][cc].R, Text );
UART1_Write_Text(Text);
UART1_Write(13); UART1_Write(10);
cont++;
if( cont==N )
{
cc = M;
ff = L;
}
}
}
UART1_Write_Text("// Fin de las muestras //");
UART1_Write(13); UART1_Write(10);
}
}

238
Para simular este ejercicio en ISIS, se implementa un circuito similar al ejercicio anterior de
transformada discreta de Fourier. Sustituyendo el PIC, por un 18F4585, y anexando un
VIRTUAL TERMINAL. El circuito para simular es el siguiente:

Circuito 14-3
14.9 Control digital PID
El en mbito del control automtico la forma de control ms popular es el PID, que significa
proporcional, integral, derivativo. El control es una rama de la fsica y la electrnica que permite
manipular una variable fsica para permanecer en un valor deseado arbitrariamente. Todo sistema
de control cuenta con las siguientes caractersticas:

- Punto de control
- Error
- Controlador (PID)
- Correccin
- Planta
- Variable a controlar
- Sensor o transductor

Ests caractersticas se pueden apreciar en el siguiente diagrama en bloques:



Figura 14-20
239

Para el caso del microcontrolador su funcin est sujeta a la entrada del punto de control, la
lectura del sensor, y la salida de correccin. El punto de partida de un controlador es el
controlador PID anlogo que tiene una funcin de transferencia PID(s), est funcin tiene una
relacin similar a un conjunto de filtros y su tratamiento es equivalente a un filtro IIR. La funcin
de transferencia anloga es la siguiente:

sKd
s
Ki
Kp s PID + + = ) (
Ecuacin 14-30

De la misma forma que se hace con los filtros IIR, se realiza la transformacin bilineal, y este
desarrollo da el siguiente anlisis:

) 1 (
) 1 ( 2
) 1 (
) 1 (
2
) (
) 1 (
) 1 ( 2
) 1 ( 2
) 1 (
) (
) 1 (
) 1 ( 2
) 1 (
) 1 ( 2
) (
1
1
1
1
1
1
1
1
1
1
1
1

+

+

+
+ =
+

+

+
+ =
+

+
+

+ =
z
z FsKd
z
z
Fs
Ki
Kp z PID
z
z FsKd
z Fs
z Ki
Kp z PID
z
z FsKd
z
z Fs
Ki
Kp z PID


Del anterior anlisis se pueden deducir tres funciones de transferencia para el controlador donde
la entrada, es la seal de error para cada una de ellas. Las respectivas operaciones matemticas
para su implementacin son las siguientes:

) ( ) ( ) ( ) (
) 1 ( )] 1 ( ) ( [ 2 ) (
) 1 ( )] 1 ( ) ( [
2
) (
) ( ] [ ) (
n y n y n y n y
n y n e n e FsKd n y
n y n e n e
Fs
Ki
n y
n e Kp n y
d i p pid
d d
i i
p
+ + =
=
+ + =
=
Ecuacin 14-31

Para el caso particular del siguiente ejemplo se emplea la tcnica de conversin digital anlogo
por medio de una salida PWM, y como estrategia para simular el comportamiento de la planta se
usa un circuito RC, de segundo orden. El siguiente cdigo fuente muestra un control PID
correspondiente a la sintonizacin del control PID, cuando su Kp crtico es de 1,8 y un periodo
crtico de 41,2m segundos.

//Declaracin de constantes y variables.
const float Kp=1.08, Ki=52.42718447, Kd=0.005562, Fs = 152.5878906;
//Declaracin de coeficientes de integracin y derivacin.
const float Fi=ki/(2.0*Fs), Fd=2.0*Fs*Kd;

240
float SENSOR, PUNTO_DE_CONTROL=127.0, YN=0.0;
int ADQUI;
unsigned short SALIDA;

float e0=0.0, e1=0.0, yi0=0.0, yi1=0.0, yd0=0.0, yd1=0.0, ypid=0.0;

//Funcin de interrupciones para el Timer 0.
void interrupt()
{
if( INTCON.F2 )// 6,5536ms :: 152,5878906 Hz
{
//Adquisicin de la variable controlada.
SENSOR = (float)((ADC_Read(1)>>2)&0xFF);
//Adquisicin del punto de control.
PUNTO_DE_CONTROL = (float)((ADC_Read(0)>>2)&0xFF);
//Calculo del nivel de error.
e0 = PUNTO_DE_CONTROL - SENSOR;
//Ecuacin en diferencias.
//Ecuacin integral.
yi0=Fi*(e0+e1)+yi1;
//Ecuacin derivativa.
yd0=Fd*(e0-e1)-yd1;
//Resultado PID.
ypid=Kp*e0+yi0+yd0;
//Ajuste y correccin de la SALIDA Y(n)
//delimitada por los lmites 0 y 255.
YN += ypid;
if(YN>255.0)YN=255.0;
if(YN<0.0)YN=0.0;
SALIDA = (unsigned short)(YN);
PWM1_Set_Duty(SALIDA);
//Actualizacin de muestras.
e1=e0;
yi1=yi0;
yd1=yd0;
INTCON.F2=0;
}
}

void main( void )
{
//Configuracin del modulo PWM.
PWM1_Init(10000);
PWM1_Start();
//Configuracin de la interrupcin de Timer 0.
//a 6,5536ms
OPTION_REG = 0b00000110;
INTCON = 0b10100000;
while( 1 ) //Bucle infinito.
241
{
}
}


El circuito para simular implementa los dispositivos: 16F877A, POT-HG, RES, CAP, OP1P La
simulacin trabaja con reloj de 20MHz. El esquemtico del circuito es el siguiente:



Circuito 14-4


Para la sintona del controlador, y establecer las constantes Kp, Ki, y Kd, se puede usar la
siguiente estrategia:

Primero se establece el controlador con las constantes Ki, y Kd igual a 0. Posteriormente se
incrementa el valor de Kp, gradualmente hasta que la salida oscile de forma sostenida. Cuando
esto sucede se mide el periodo de la oscilacin sostenida y se determina el valor de Kp. Estos dos
parmetros se denominan periodo crtico Pc, y Kp crtico Kpc. Posteriormente estos valores se
remplazan en la siguiente tabla, para determinar los valores definitivos de Kp, Ki, y Kd:

Tipo de control Kp Ti Td
P 0,5Kpc Infinito, Ki=0 0
PI 0,45Kpc Pc/1,2 0
PID 0,6Kpc 0,5Pc 0,125Pc

Tabla 14-2

Donde, Ti es el periodo de integracin y Td el periodo derivativo. La relacin de estos periodos
con las constantes Ki, y Kd se especifica en las siguientes ecuaciones:
242

TdKp Kd
Ti
Kp
Ki
=
=
Ecuacin 14-32
243
15 Transmisin de datos
La transmisin de datos es una lnea de las comunicaciones electrnicas que se encarga de
garantizar el transporte de informacin de forma digital. La informacin enviada puede ser
bloques de texto, de audio, video, o cualquier otro tipo de informacin. Para realizar la
transmisin de informacin se pueden seguir diversos formatos y protocolos, sin embargo este
captulo se centra en tcnicas bsicas de transmisin de datos como son, el control de flujo de la
informacin, la transparencia de datos y el control de errores. Las tcnicas de transmisin de
datos permiten optimizar y garantizar el estado correcto de los datos durante una transmisin de
datos. Este es un aspecto importante dado que un medio de transmisin est expuesto a producir
errores por razones de ruido o falta de continuidad en el medio de transmisin de datos. El
siguiente grafico ilustra de forma simple el trfico de informacin entre dos puntos que gestionan
una comunicacin.


Figura 15-1

244
15.1 Control de flujo
El control de flujo permite gestionar el trfico de informacin de forma ordenada. Cuando el
medio de transmisin es altamente confiable, se puede implementar solamente el control de flujo.
Por otro lado es importante tener presente que los ejemplos mostrados en este captulo trafican
con la informacin en cdigo ASCII, y el carcter de reconocimiento positivo ACK, se representa
con el valor 0x06, el carcter de reconocimiento negativo NAK, se representa con el cdigo
0x15, los finales de cadenas de texto o de caracteres se representan con el carcter nulo NULL
que equivale al cdigo 0x00. El siguiente ejemplo muestra una comunicacin simples con el
respectivo control de flujo, implementado con un microcontrolador PIC 16F628A, con oscilador
de 4MHz.

// Declaracin de constantes del LCD
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D7_Direction at TRISB7_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB4_bit;

//Declaracin de variables de trabajo.
char BUFER[20], Dato, Bandera=0;
unsigned short Estado=0, N=0;

//Declaracin de constantes.
const char ACK='A', NAK='N', ENQ='&', EOT='%', NULL=0x00;

//Vector de interrupciones.
void interrupt()
{
//Se evala la interrupcin por recepcin serial.
if( PIR1.F5 )
{
//Se lee el Dato de entrada.
Dato = UART1_Read();
//Se evala el estado del trfico de informacin.
switch( Estado )
{
//En espera...
case 0: //Se evala si llega una solicitud..
if( Dato == ENQ )
{
//Se cambia al siguiente Estado y se
245
//enva el reconocimiento positivo.
Estado = 1;
N = 0;
UART1_Write(ACK);
}
else
{
//Se enva reconocimiento negativo.
UART1_Write(NAK);
}
break;
//Recibiendo...
case 1: // Se evala si lo que llega es el final de transmisin EOT
if( Dato == EOT )
{
//Llega el fin de la informacin y se vuelve
//al Estado inicial y se activa la Bandera de datos
//de llegada.
BUFER[N] = NULL;
Estado = 0;
Bandera = 1;
}
else
{
//Se archiva el Dato recibido y se incrementa
//el indicador N
BUFER[N] = Dato;
N++;
}

default: break;
}
}
}

void main( void )
{
//Se activan las interrupciones perifricas.
INTCON = 0b11000000;
//Se activa la interrupcin por recepcin serial.
PIE1 = 0b00100000;
//Configuracin del modulo USART a 9600 bps.
UART1_Init(9600);
//Configuracin del LCD.
Lcd_Init();

Lcd_Out(1,1,"Control de Flujo");

while(1) //Bucle infinito.
246
{
//Se evala si la Bandera esta activa.
if( Bandera == 1 )
{
//Se imprime la informacin en el LCD.
Lcd_Out(2,1," ");
Lcd_Out(2,1,BUFER);
Bandera = 0;
}
}
}

Es importante notar que en la declaracin de constantes se usan como caracteres de ACK, NAK,
ENQ y EOT, los caracteres A, N, &, y %, esto solo se realiza en este ejemplo de forma didctica
dado que este tipo de caracteres tienen valores y equivalencias que no se pueden ver ni digitar en
el VIRTUAL TERMINAL.

Para realizar la respectiva simulacin de este ejemplo se implementa en ISIS los dispositivos
PIC16F628A, VIRTUAL TERMINAL, y LM016L, en un circuito como el siguiente:


Circuito 15-1

La transmisin de informacin obedece a la siguiente estructura:


Figura 15-2
247
15.2 Transparencia de datos
La transparencia de datos es la capacidad de empaquetar informacin con un bloque de inicio o
encabezado y un bloque final del paquete de informacin, el xito de la transparencia esta en no
repetir los datos de encabezado o final dentro de la informacin. De esta manera se puede ver de
forma transparente la informacin dentro de los datos de control. Para encabezar la informacin
se implementa el carcter DLE o marcador de transparencia equivalente al cdigo 0x10, STX
comienzo de texto que equivale al cdigo 0x02, y para finalizar el bloque de datos se usa el
carcter ETX que es equivalente a 0x03.

Para demostrar el funcionamiento de la estructura de transparencia se implementan a
continuacin dos programas uno que transmite informacin y otro que la recibe, los programas
esta fundamentados en un microcontrolador PIC 16F628A, y un PIC 16F877A ambos con
oscilador de 4MHz, a continuacin se puede apreciar el cdigo fuente del modulo receptor que es
similar al ejemplo del control de flujo:

// Declaracin de constantes del LCD
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D7_Direction at TRISB7_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB4_bit;

//Declaracin de variables de trabajo.
char BUFER[20], Dato, Bandera=0;
unsigned short Estado=0, N=0;

//Declaracin de constantes.
const char ACK=0x06, NAK=0x15, ENQ=0x05, EOT=0x04, STX=0x02, ETX=0x03,
DLE=0x10,
NULL=0x00;

//Vector de interrupciones.
void interrupt()
{
//Se evala la interrupcin por recepcin serial.
if( PIR1.F5 )
{
//Se lee el Dato de entrada.
Dato = UART1_Read();
//Se evala el estado del trfico de informacin.
switch( Estado )
248
{
//En espera...
case 0: //Se evala si llega una solicitud..
if( Dato == ENQ )
{
//Se cambia al siguiente Estado y se
//enva el reconocimiento positivo.
Estado = 1;
UART1_Write(ACK);
}
else
{
//Se enva reconocimiento negativo.
UART1_Write(NAK);
}
break;
//Delimitador de transparencia...
case 1: // Se evala si lo que llega es DLE.
if( Dato == DLE )
{
//Se cambia al siguiente Estado...
Estado = 2;
}
else
{
//Se identifica un error de orden en los datos
//y se transmite un reconocimiento negativo y se
//reanuda al Estado inicial.
//Se reinicia de nuevo al Estado inicial.
Estado = 0;
UART1_Write(NAK);
}
break;
// Recibiendo informacin...
case 2: // Se evala si lo que llega es STX.
if( Dato == STX )
{
//Se inicia la cadena de informacin y se
//pasa al Estado 3
N=0;
BUFER[N]=NULL;
Estado = 3;
}
else
{
//Se identifica un error de orden en los datos
//y se transmite un reconocimiento negativo y se
//reanuda al Estado inicial.
//Se reinicia de nuevo al Estado inicial.
249
Estado = 0;
UART1_Write(NAK);
}
break;
// Esperando datos y delimitador de transparencia.
case 3: //Se evala si el Dato que llega es un DLE.
if( Dato == DLE )
{
//Se cambia al Estado siguiente.
Estado = 4;
//Se finaliza el BUFER de datos;
BUFER[N]=NULL;
}
else
{
//Se anexa un nuevo Dato al BUFER.
BUFER[N]=Dato;
//Se incrementa el ndice de los datos.
N++;
}
break;
// Esperando fin de cadena...
case 4: // Se evala si llega un ETX
if( Dato == ETX )
{
//Se cambia al Estado siguiente.
Estado = 5;
}
else
{
//Se cambia de nuevo al Estado inicial.
Estado = 0;
//Se transmite reconocimiento negativo.
UART1_Write(NAK);
}
break;
//Esperando fin de transmisin...
case 5: //Se evala si llega el EOT...
if( Dato == EOT )
{
//Se activa la Bandera de llegada de informacin.
Bandera = 1;
//Se transmite reconocimiento positivo.
UART1_Write(ACK);
}
else
{
//Se transmite reconocimiento negativo.
UART1_Write(NAK);
250
}
Estado = 0;
break;

default: break;
}
}
}

void main( void )
{
//Se activan las interrupciones perifricas.
INTCON = 0b11000000;
//Se activa la interrupcin por recepcin serial.
PIE1 = 0b00100000;
//Configuracin del modulo USART a 9600 bps.
UART1_Init(9600);
//Configuracin del LCD.
Lcd_Init();
//Texto de inicio.
Lcd_Out(1,1,"Transparencia");
while(1) //Bucle infinito.
{
//Se evala si la Bandera esta activa.
if( Bandera == 1 )
{
//Se imprime la informacin en el LCD.
Lcd_Out(2,1," ");
Lcd_Out(2,1,BUFER);
Bandera = 0;
}
}
}

El siguiente programa est diseado para un microcontrolador PIC 16F877A, el cual toma la
lectura de un sensor LM35, y la transmite con el respectivo control de flujo y transparencia:

//Declaracin de constantes.
const char ACK=0x06, NAK=0x15, ENQ=0x05, EOT=0x04, STX=0x02, ETX=0x03,
DLE=0x10, NULL=0x00;

void main( void )
{
char BUFER[10];
int adc;
float Temp;
//Se configura el modulo ADC, con el pin
//AN3 como voltaje de referencia.
ADCON1 = 0b11000001;
251
//Se inicia el modulo USART a 9600 bps.
UART1_Init(9600);
delay_ms(500);
while(1)//Bucle infinito.
{
OTRO:
//Lectura del canal 0
adc = ADC_Read(0);
//Se calcula el valor de la temperatura.
Temp = 0.244*adc;
//Se escribe la temperatura en el BUFER.
FloatToStr( Temp, BUFER );
//Retardo de lectura de 400m segundos
delay_ms(100);
//Se transmite el ENQ...
UART1_Write(ENQ);
//Se espera el ACK...
while( !UART1_Data_Ready() );
//Se verifica si llega un ACK...
if( UART1_Read() != ACK )goto OTRO;
//Se transmite un DLE...
UART1_Write(DLE);
//Se transmite un STX...
UART1_Write(STX);
//Se transmite la informacin del BUFER...
UART1_Write_Text(BUFER);
//Se transmite un DLE...
UART1_Write(DLE);
//Se transmite el ETX...
UART1_Write(ETX);
//Se transmite el fin de transmisin...
UART1_Write(EOT);
//Se espera el ACK
while( !UART1_Data_Ready() );
//Se verifica si llega un ACK...
if( UART1_Read() != ACK )goto OTRO;
}
}

La estructura para la transparencia de datos obedece a la siguiente forma:



Figura 15-3
252
Para realizar la respectiva simulacin se realiza el siguiente circuito que tiene los dispositivos,
PIC 16F628A, PIC 16F877A, RES, LM016L, LM35:



Circuito 15-2


15.3 Control de errores CRC
El control de errores en una transmisin es de suma importancia y ms cuando la calidad del
medio de transmisin no es confiable. Para detectar los errores de transmisin existen diferentes
tcnicas entre las cuales se pueden citar, VRC o verificacin de redundancia vertical, esta
estrategia anexa un bit ms a cada paquete de informacin el cual representa el nmero par o
impar de unos en el paquete. LRC o Verificacin de redundancia longitudinal la cual verifica el
nmero de bits pares o impares en un grupo de bytes, para este fin se realiza la operacin lgica o
exclusiva, entre ellos. Por ltimo se puede hablar del CRC, o verificacin de redundancia cclica,
que es la estrategia de mayor efectividad, y que es la tcnica en la cual se centra el ejemplo de
este captulo. Para llegar al resultado del CRC, se efecta una divisin binaria entre el paquete de
datos que se desean transmitir y un polinomio fijo que debe respetar algunas condiciones.
Despus de hacer la divisin el residuo de la misma es anexado al paquete de informacin y este
es el CRC. El ente receptor realiza la misma divisin con el mismo polinomio y despus de
culminarla el resultado consignado en el residuo debe ser 0 si los datos han llegado sin ningn
error, de lo contrario los datos del paquete estn deteriorados.



La estructura de informacin con el CRC incorporado se implementa en la forma que se puede
apreciar en la siguiente figura:

253


Figura 15-4

Los polinomios que se implementan en el clculo del CRC se denotan en trminos de X, en el
cual cada X, es un 1 en el polinomio, para ilustrar esta situacin se puede apreciar el siguiente
ejemplo:

Este polinomio equivale al siguiente nmero binario:

10100111

Para que los polinomios funciones de forma adecuada deben cumplir con las siguientes
condiciones:

- Debe empezar y terminar con un 1.
- No debe ser divisible por X, es decir por 10.
- Debe ser divisible por X+1, es decir por 11.

Los siguientes son polinomios estndar para diferente nmero de bits:


CRC-4

CRC-8

CRC-12

CRC-16

CRC-32

El siguiente ejemplo aritmtico muestra una divisin para generar el CRC, y su respectiva
verificacin:
254


La implementacin de una divisin de este modo es demasiado compleja. Cuanto ms larga sea
la trama ms difcil es realizarla, por eso es ms simple realizar una operacin lgica con
registros de desplazamiento como estrategia para determinar el residuo de la divisin. El
siguiente diagrama muestra un circuito para el polinomio:

Figura 15-5

Usando como estrategia de programacin el corrimiento de bits como lo muestra la figura se
puede hacer un conjunto de funciones que calculen el CRC, sobre una trama de longitud
indefinida teniendo como base mnima un byte y polinomios con orden mltiplo de 8, tales como
8, 16, 24, 32. Para comprender con claridad este concepto se puede observar el siguiente ejemplo
que usa un polinomio de orden 8:

Polinomio:

100110001
Informacin 1 0 1 1 0 1 0 1 1
Polinomio 1 0 0 1 1
1 0 1 1 0 1 0 1 1 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1 0 0
1 0 0 1 1 1 0 0 1 1
0 1 0 1 1 0 1 0 1 1
0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 0 1 1 0
1 0 0 1 1 1 0 0 1 1
0 1 0 1 1 0 1 0 1 1
0 0 0 0 0 0 0 0 0 0
1 0 1 1 1 1 0 1 1 1
1 0 0 1 1 1 0 0 1 1
0 1 0 0 0 0 1 0 0 1
0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 1 0 0 1 1
1 0 0 1 1 1 0 0 1 1
0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0 Chequeo
Calculo del CRC Chequeo del CRC
Se cambia el polinomio por 0
dado que el bit mas
significativo es cero
CRC
255
unsigned short CRC=0;

//Funcin para insertar in bit en el clculo del CRC.
void CorrerBitCRC( char _bit )
{
unsigned short CRC2=0;
CRC2 = CRC2 | (CRC<<1)&128; //Set X7
CRC2 = CRC2 | (CRC<<1)&64; //Set X6
CRC2 = CRC2 | ((CRC<<1)^(CRC>>2))&32; //Set X5
CRC2 = CRC2 | ((CRC<<1)^(CRC>>3))&16; //Set X4
CRC2 = CRC2 | (CRC<<1)&8; //Set X3
CRC2 = CRC2 | (CRC<<1)&4; //Set X2
CRC2 = CRC2 | (CRC<<1)&2; //Set X1
CRC2 = CRC2 | ((CRC>>7)^_bit)&1; //Set X0
CRC = CRC2;
}
//Funcin para insertar un Byte al clculo del CRC.
void CorrerByteCRC( char Byte )
{
short B;
for( B=7; B>=0; B-- )
CorrerBitCRC( (Byte>>B)&1 );
}

//Funcin para calcular el CRC de una trama de texto.
unsigned short CalcularRCR( char *trama, unsigned char FINAL )
{
unsigned short N=0;
CRC = 0;
while( trama[N]!=0 )
{
CorrerByteCRC( trama[N] );
N++;
}
CorrerByteCRC( FINAL );
return CRC;
}

Para realizar la implementacin de este ejemplo, se usa el mismo hardware del ejemplo de
transparencia, el cdigo fuente para el microcontrolador transmisor implementando el CRC es el
siguiente:

//Funcin para insertar un Byte al clculo del CRC.
void CorrerByteCRC( char Byte )
{
short B;
for( B=7; B>=0; B-- )
CorrerBitCRC( (Byte>>B)&1 );
}
256
//Funcin para calcular el CRC de una trama de texto.
unsigned short CalcularRCR( char *trama, unsigned char FINAL )
{
unsigned short N=0;
CRC = 0;
while( trama[N]!=0 )
{
CorrerByteCRC( trama[N] );
N++;
}
CorrerByteCRC( FINAL );
return CRC;
}

void main( void )
{
char BUFER[10];
int adc;
float Temp;
//Se configura el modulo ADC, con el pin
//AN3 como voltaje de referencia.
ADCON1 = 0b11000001;
//Se inicia el modulo USART a 9600 bps.
UART1_Init(9600);
delay_ms(500);
while(1)//Bucle infinito.
{
OTRO:
//Lectura del canal 0
adc = ADC_Read(0);
//Se calcula el valor de la temperatura.
Temp = 0.244*adc;
//Se escribe la temperatura en el BUFER.
FloatToStr( Temp, BUFER );
//Calculo del CRC.
CalcularRCR( BUFER, 0 );
//Retardo de lectura de 400m segundos
delay_ms(100);
//Se transmite el ENQ...
UART1_Write(ENQ);
//Se espera el ACK...
while( !UART1_Data_Ready() );
//Se verifica si llega un ACK...
if( UART1_Read() != ACK )goto OTRO;
//Se transmite un DLE...
UART1_Write(DLE);
//Se transmite un STX...
UART1_Write(STX);
//Se transmite la informacin del BUFER...
257
UART1_Write_Text(BUFER);
//Se transmite el CRC...
UART1_Write(CRC);
//Se transmite un DLE...
UART1_Write(DLE);
//Se transmite el ETX...
UART1_Write(ETX);
//Se transmite el fin de transmisin...
UART1_Write(EOT);
//Se espera el ACK...
while( !UART1_Data_Ready() );
//Se verifica si llega un ACK...
if( UART1_Read() != ACK )goto OTRO;
}
}


El cdigo fuente para el microcontrolador receptor con la implementacin del CRC es el
siguiente:

// Declaracin de constantes del LCD
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D7_Direction at TRISB7_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB4_bit;

//Declaracin de variables de trabajo.
char BUFER[20], Dato, Bandera=0;
unsigned short Estado=0, N=0;

//Declaracin de constantes.
const char ACK=0x06, NAK=0x15, ENQ=0x05, EOT=0x04, STX=0x02, ETX=0x03,
DLE=0x10,
NULL=0x00;

unsigned short CRC=0, CRC_2, Lon;

//Funcin para insertar in bit en el clculo del CRC.
void CorrerBitCRC( char _bit )
{
unsigned short CRC2=0;
258
CRC2 = CRC2 | (CRC<<1)&128; //Set X7
CRC2 = CRC2 | (CRC<<1)&64; //Set X6
CRC2 = CRC2 | ((CRC<<1)^(CRC>>2))&32; //Set X5
CRC2 = CRC2 | ((CRC<<1)^(CRC>>3))&16; //Set X4
CRC2 = CRC2 | (CRC<<1)&8; //Set X3
CRC2 = CRC2 | (CRC<<1)&4; //Set X2
CRC2 = CRC2 | (CRC<<1)&2; //Set X1
CRC2 = CRC2 | ((CRC>>7)^_bit)&1; //Set X0
CRC = CRC2;
}

//Funcin para insertar un Byte al clculo del CRC.
void CorrerByteCRC( char Byte )
{
short B;
for( B=7; B>=0; B-- )
CorrerBitCRC( (Byte>>B)&1 );
}

//Funcin para calcular el CRC de una trama de texto.
unsigned short CalcularRCR( char *trama, unsigned char FINAL )
{
unsigned short N=0;
CRC = 0;
while( trama[N]!=0 )
{
CorrerByteCRC( trama[N] );
N++;
}
CorrerByteCRC( FINAL );
return CRC;
}

//Vector de interrupciones.
void interrupt()
{
//Se evala la interrupcin por recepcin serial.
if( PIR1.F5 )
{
//Se lee el Dato de entrada.
Dato = UART1_Read();
//Se evala el estado del trfico de informacin.
switch( Estado )
{
//En espera...
case 0: //Se evala si llega una solicitud..
if( Dato == ENQ )
{
//Se cambia al siguiente Estado y se
259
//enva el reconocimiento positivo.
Estado = 1;
UART1_Write(ACK);
}
else
{
//Se enva reconocimiento negativo.
UART1_Write(NAK);
}
break;
//Delimitador de transparencia...
case 1: // Se evala si lo que llega es DLE.
if( Dato == DLE )
{
//Se cambia al siguiente Estado...
Estado = 2;
}
else
{
//Se identifica un error de orden en los datos
//y se transmite un reconocimiento negativo y se
//reanuda al Estado inicial.
//Se reinicia de nuevo al Estado inicial.
Estado = 0;
UART1_Write(NAK);
}
break;
// Recibiendo informacin...
case 2: // Se evala si lo que llega es STX.
if( Dato == STX )
{
//Se inicia la cadena de informacin y se
//pasa al Estado 3
N=0;
BUFER[N]=NULL;
Estado = 3;
}
else
{
//Se identifica un error de orden en los datos
//y se transmite un reconocimiento negativo y se
//reanuda al Estado inicial.
//Se reinicia de nuevo al Estado inicial.
Estado = 0;
UART1_Write(NAK);
}
break;
// Esperando datos y delimitador de transparencia.
case 3: //Se evala si el Dato que llega es un DLE.
260
if( Dato == DLE )
{
//Se cambia al Estado siguiente.
Estado = 4;
//Se finaliza el BUFER de datos;
BUFER[N]=NULL;
}
else
{
//Se anexa un nuevo Dato al BUFER.
BUFER[N]=Dato;
//Se incrementa el ndice de los datos.
N++;
}
break;
// Esperando fin de cadena...
case 4: // Se evalua si llega un ETX
if( Dato == ETX )
{
//Se cambia al Estado siguiente.
Estado = 5;
}
else
{
//Se cambia de nuevo al Estado inicial.
Estado = 0;
//Se transmite reconocimiento negativo.
UART1_Write(NAK);
}
break;
//Esperando fin de transmisin...
case 5: //Se evala si llega el EOT...
if( Dato == EOT )
{
//Se mide la longitud de la trama.
Lon = strlen(BUFER);
//Se filtra el CRC, que est en la ltima posicin.
CRC_2 = BUFER[Lon-1];
BUFER[Lon-1]=0;
//Se calcula el CRC...
CalcularRCR( BUFER, CRC_2 );
// Se verifica que el chequeo sea cero...
if( CRC==0 )
{
//Se activa la Bandera de llegada de informacin.
Bandera = 1;
//Se transmite reconocimiento positivo.
UART1_Write(ACK);
}
261
else
{
//Se transmite reconocimiento negativo.
UART1_Write(NAK);
}
}
else
{
//Se transmite reconocimiento negativo.
UART1_Write(NAK);
}
Estado = 0;
break;
default: break;
}
}
}

void main( void )
{
//Se activan las interrupciones perifricas.
INTCON = 0b11000000;
//Se activa la interrupcin por recepcin serial.
PIE1 = 0b00100000;
//Configuracin del modulo USART a 9600 bps.
UART1_Init(9600);
//Configuracin del LCD.
Lcd_Init();
//Texto de inicio.
Lcd_Out(1,1,"Transparencia");
while(1) //Bucle infinito.
{
//Se evala si la Bandera esta activa.
if( Bandera == 1 )
{
//Se imprime la informacin en el LCD.
Lcd_Out(2,1," ");
Lcd_Out(2,1,BUFER);
Bandera = 0;
}
}
}

262
16 Actuadores y potencia
Los actuadores son dispositivos elctricos o electrnicos que permiten crear un cambio fsico
sobre una variable. Est pueden ser temperatura, velocidad, presin, luminosidad, humedad,
posicin angular o lineal, entre otras. Los actuadores pueden ser de accionamiento AC, o DC. Los
actuadores DC, son aquellos como motores, servomotores, lmparas incandescentes, solenoides,
relevadores, entre otros. Los actuadores AC, son aquellos como motores AC, lmparas
incandescentes, resistencias elctricas, entre otros. Por otra parte la potencia es la cantidad
energa elctrica requerida para realizar un trabajo determinado. En el caso puntual de la
electricidad la potencia est definida como:

R I
R
V
VI P
e
2
2
= = = Ecuacin 16-1

Donde Pe es la potencia elctrica en vatios, V es la diferencia de potencial elctrico sobre una
carga elctrica con resistencia R, por la cual circula una corriente I. En el caso de un
microcontrolador el uso de un arreglo de potencia se hace indispensable cuando un actuador
requiere ms voltaje o corriente, que la que puede entregar un pin del PIC. La tensin que
entregan las salidas del PIC siempre es de 5 voltios y la corriente que puede suministrar solo
puede ser del orden de pocos miliamperios.
16.1 Actuadores DC
Los actuadores DC, requieren de corriente siempre directa es decir que siempre circula en la
misma direccin. Para el uso de estos actuadores se implementan esencialmente dos tipos de
dispositivos, los transistores de potencia o los relevadores. Los transistores pueden ser BJT, o
MOSFET. Un transistor BJT, se caracteriza por controlar una corriente por medio de otra
corriente. Los MOSFET, permiten controlar un flujo de corriente por medio de una diferencia de
potencial. Los transistores funcionan en tres zonas, conocidas como corte, saturacin y activa. La
zona activa es comn en los sistemas de amplificacin de seal. Sin embargo para el caso de los
actuadores se requieren en la mayora de los casos ser activados y desactivados, o tener un
comportamiento ON, OFF. En otras palabras los transistores se usan en corte y saturacin. Bajo
estos trminos los transistores trabajan como interruptores de corriente, en las zonas de corte y
saturacin. La vista de los transistores en ISIS es la siguiente:



Figura 16-1

263
Los transistores MOSFET, controlan la corriente que circula entre la fuente S, y el drenador D,
por medio de la diferencia de potencial elctrico sobre la compuerta G. Los transistores BJT,
controlan la corriente que fluye entre el colector C, y el emisor E, por medio de la corriente que
circula por la base B.

El uso de cargas inductivas como motores, relevadores o solenoides, tienen la propiedad de
almacenar energa en forma de campo electromagntico, esto implica que cuando las cargas
inductivas son des energizadas, ests devuelven su energa por medio de una corriente inversa,
este fenmeno puede causar daos en los sistemas controlados con transistores, para evitar este
problema se debe usar un diodo rectificador polarizado en inverso para descargar las cargas
inductivas, este arreglo se muestra en el siguiente circuito:


Circuito 16-1
16.1.1 Relevadores
Los relevadores son dispositivos electromecnicos, que tienen un electroimn con el cual se
cierra o se abre un circuito elctrico por medio de uno o varios contactos. Los relevadores son
ideales para aislar los circuitos de potencia con la etapa de control electrnico. De igual manera
son dispositivos de bajo rendimiento, dado que no pueden hacer cambios de estdo veloces, y con
el uso constante los contactos elctricos se deterioran con el tiempo. La apariencia fsica y la vista
en ISIS, de estos dispositivos es la siguiente:


Figura 16-2


Por ltimo el uso de estos dispositivos se debe hacer de forma final como se puede observar en el
siguiente circuito, que tiene una carga de 120V AC:
264

Circuito 16-2
16.1.2 Motores DC
Los motores DC, son de naturaleza inductiva y por consiguiente merecen el mismo tratamiento
de los relevadores. En el siguiente ejemplo se puede apreciar como un microcontrolador hace
cambios de velocidad en un motor DC, para este fin se implementa el mdulo PWM de un
microcontrolador 16F628A, con oscilador de 4MHz. El cdigo fuente en lenguaje C es el
siguiente:

void main( void )
{
unsigned short CU=0;
OPTION_REG = 0; //Se activan las resistencias PULL-UP.
PWM1_Init( 500 ); //Se inicia el mdulo PWM a 500Hz.
PWM1_Set_Duty(CU);
PWM1_Start();
while(1) //Bucle infinito.
{
//Bucle de incremento del PWM cuando se pulsa RB1.
while( Button( &PORTB, 1, 10, 0 ) )
{
CU++; if( CU==0 )CU=255;
PWM1_Set_Duty(CU);
delay_ms(10);
}
//Bucle de decremento del PWM cuando se pulsa RB0.
while( Button( &PORTB, 0, 10, 0 ) )
{
CU--; if( CU==255 )CU=0;
PWM1_Set_Duty(CU);
delay_ms(10);
}
}
}
265
Para poder hacer la simulacin de este ejemplo se debe implementar en ISIS los dispositivos:
16F628A, BUTTON, RES, 2N3904, 1N4001, y MOTOR ACTIVE. Configurados como se puede
apreciar en el siguiente circuito:

Circuito 16-3

En funcin de la intensidad de corriente se puede cambiar el transistor para optimizar el
funcionamiento de los sistemas. Un transistor como el 2N3904 puede controlar una corriente de
200m Amperios, y un TIP31 puede controlar una corriente de 3 Amperios, en funcin de la
referencia y sus caractersticas, se puede asumir un mximo de corriente.
16.1.3 Puente H
Los puentes H son arreglos transistorizados que permiten invertir la polaridad sobre una carga
elctrica, con el suministro de solo una fuente sencilla. Los puentes H, se pueden implementar en
discreto con transistores o usar mdulos integrados que se pueden conseguir comercialmente.
Estos arreglos cuentan con dos seales de control que permiten activar la polaridad positiva, y
negativa. Un diseo discreto de este arreglo se puede apreciar en el siguiente circuito:


Circuito 16-4
266
Para activar una polaridad positiva, se activa el control 1, y se apaga el control 2, para activar la
polaridad negativa se hace la configuracin contraria con los pines de control. Se debe tener
presente que nunca se podrn activar los dos puntos de control al mismo tiempo, est accin
genera un corto circuito entre Vcc, y referencia, produciendo daos considerables sobre los
transistores.

El siguiente ejemplo muestra el control de giro sobre un motor DC, por medio de un
microcontrolador 16F628A:

void main( void )
{

OPTION_REG = 0; //Se activan las resistencias PULL-UP.
//Configuracin de salida y entrada del puerto B.
PORTB = 0;
TRISB = 0x0F;
PORTB = 0;

while(1) //Bucle infinito.
{

//Bucle para detectar el botn de giro a la izquierda.
while( Button( &PORTB, 0, 10, 0 ) )
{
PORTB = 0; //Se apagan los pines de control.
PORTB.F7 = 1; //Se activa el pin de control 1.
}

//Bucle para detectar el botn de detener.
while( Button( &PORTB, 1, 10, 0 ) )
{
PORTB = 0; //Se apagan los pines de control.
}

//Bucle para detectar el botn de giro a la derecha.
while( Button( &PORTB, 2, 10, 0 ) )
{
PORTB = 0; //Se apagan los pines de control.
PORTB.F6 = 1; //Se activa el pin de control 2.
}

}

}

267
La simulacin en ISIS, se realiza por medio del siguiente circuito electrnico:


Circuito 16-5
16.1.4 Motores Paso
Los motores paso, son dispositivos electromecnicos que permiten hacer giros fraccionados por
grados, los motores paso son de dos naturalezas; unipolares y bipolares. Un motor unipolar
cuenta con cuatro embobinados, que se energizan uno o dos a la vez, y siempre con la misma
polaridad. Los motores paso bipolares cuentan con solo dos bobinas, las cuales se polarizan al
mismo tiempo, pero alternando la polaridad. Este efecto genera una secuencia en las bobinas y su
polaridad. Manipulando la velocidad de la secuencia se controla la velocidad de giro del motor, y
con el orden de la secuencia se controla la direccin de giro del motor.

En las siguientes grficas se puede apreciar la apariencia fsica de estos motores y su vista en
ISIS:


Figura 16-3

Los motores unipolares, cuentan generalmente con 5 o 6 terminales, de las cuales 4 corresponden
a los embobinados, y 1 o 2 son terminales comunes. Las bobinas de un motor unipolar se pueden
apreciar en el siguiente circuito:

268

Circuito 16-6

La secuencia de activacin para los motores unipolares puede ser de dos formas; con una sola
entrada activa, o dos entradas activas simultneamente. Cuando se activan dos entradas
simultneamente el torque del motor es mayor pero al mismo tiempo la corriente es mayor. La
siguiente tabla muestra la forma de activar las secuencias en los dos casos:

Secuencias para motores paso unipolares
PASO
Secuencia con una activacin Secuencia con dos activaciones
L A L B L C L D L A L B L C L D
1 ON OFF OFF OFF ON ON OFF OFF
2 OFF ON OFF OFF OFF ON ON OFF
3 OFF OFF ON OFF OFF OFF ON ON
4 OFF OFF OFF ON ON OFF OFF ON

Tabla 16-1

El siguiente ejemplo muestra como realizar el control de un motor unipolar con un PIC 16F628A,
que cuenta con una frecuencia de reloj de 4MHz, para este fin la secuencia del motor se guarda
en un arreglo. El cdigo en lenguaje C es el siguiente:

//Constantes con la secuencia de pasos.
const unsigned short PASOS[4] =
{
0b00000001,
0b00000010,
0b00000100,
0b00001000
};

void main( void )
{
//Declaracin de variables.
unsigned short PASO=0;
//Inicio del puerto
TRISB = 0xF0;
PORTB = 0;
OPTION_REG = 0; //Activacin de las resistencias PULL-UP.
269
while(1)//Bucle infinito.
{
//Bucle while para hacer girar en un sentido
//por medio del pin RB6
while( Button( &PORTB, 6, 100, 0) )
{
PORTB = PASOS[PASO];
PASO++;
if( PASO==4 )PASO=0;
}
//Bucle while para hacer girar en un sentido contrario
//por medio del pin RB7
while( Button( &PORTB, 7, 100, 0) )
{
PORTB = PASOS[PASO];
PASO--;
if( PASO==255 )PASO=3;
}
}
}

Para simular este ejercicio se implementa en ISIS, el siguiente circuito electrnico, con el
MOTOR-STEPPER, BUTTON, y el driver ULN2003A:


Circuito 16-7

Para realizar el ejercicio con la secuencia de doble activacin simplemente se cambia la
secuencia en el arreglo del mismo programa y se usa la misma simulacin. El nuevo arreglo es el
siguiente:

//Constantes con la secuencia de pasos.
const unsigned short PASOS[4] =
{
0b00000011,
0b00000110,
270
0b00001100,
0b00001001
};

Para los motores bipolares se implementa un puente H doble, de tal forma que se pueda hacer una
secuencia con doble polaridad. La distribucin elctrica de este tipo de motores es la siguiente:



Circuito 16-8

Para el control de este tipo de motores se requiere de la siguiente secuencia de polaridad:

PASO
Secuencia para Bipolar
L A L B L C L D
1 +V -V +V -V
2 +V -V -V +V
3 -V +V -V +V
4 -V +V +V -V

Tabla 16-2

Para realizar el ejercicio con este motor se implementa el mismo programa del motor unipolar y
se altera el arreglo de la secuencia, en este nuevo arreglo se asume un 1 lgico para los +V, de la
tabla y un 0 lgico para los V. De esta forma se obtiene el siguiente arreglo:

//Constantes con la secuencia de pasos.
const unsigned short PASOS[4] =
{
0b00000101,
0b00001001,
0b00001010,
0b00000110
};


Para la simulacin del sistema se implementa en ISIS un circuito similar, pero con un motor
bipolar y un driver para puente H integrado. Este integrado es el L293D, que es un circuito
integrado que tiene en su interior dos puentes H simultneamente, caracterstica que lo hace ideal
para este tipo de motores. La simulacin en ISIS, implementa el 16F628A, BUTTON, MOTOR-
BISTEPPER, y el L293D. El circuito para simular es el siguiente:
271

Circuito 16-9
16.1.5 Servomotores
Los servomotores son sistemas integrados que tienen un control de posicin angular, y un sistema
mecnico de piones para ofrecer mayor fuerza pero menor velocidad. Un servomotor tiene
incorporado un control de posicin angular, que puede ser gobernado por medio de una seal
PWM. Las aplicaciones de los servomotores estn desde la robtica hasta los modelos a escala
como aviones, helicpteros y carros. Los servomotores cuentan con un terminal de tres pines para
la alimentacin, la referencia y la seal de control PWM. La apariencia fsica y la vista en ISIS de
estos dispositivos es la siguiente:


Figura 16-4

La caracterstica de la seal de control es su periodo de PWM de 16m a 18m segundos y el
periodo til puede variar de 1 a 2 milisegundos, esto hace referencia respectivamente a 0 y 180
grados en la posicin angular. La siguiente grfica ilustra est situacin:


Figura 16-5
272
A continuacin se muestra un ejemplo en lenguaje C, para controlar la posicin de un
servomotor:

//Funcin para generar el PWM de
//baja frecuencia, ajustado para
//cristal de 20MHz.
void Pwm_Sevo( float ang )
{
unsigned int n, max;
max = 1.61*ang;
PORTB.F0 = 1;
delay_ms(1);
for( n=0; n<max; n++ )
delay_us(1);
PORTB.F0=0;
delay_ms(15);
}

void main( void )
{
//Angulo inicial.
float ANGULO=90;
//Inicio del puerto
TRISB.F0 = 0;
//Se activan las resistencias PULL-UP.
OPTION_REG=0;
while(1)//Bucle infinito.
{
Pwm_Sevo(ANGULO); //Se genera un pulso.
//Si se pulsa el botn de RB6
//se decrementan 10 grados.
if( PORTB.F6==0 )
{
ANGULO-=10.0;
if( ANGULO<0.0 )ANGULO=0.0;
while( Button(&PORTB,6,5,0) );
}
//Si se pulsa el botn de RB7
//se incrementan 10 grados.
if( PORTB.F7==0 )
{
ANGULO+=10.0;
if( ANGULO>180.0 )ANGULO=180.0;
while( Button(&PORTB,7,5,0) );
}
}
}

273
Para simular este ejercicio, se implementa en ISIS, el PIC 16F628A, con frecuencia de reloj de
20MHz, MOTOR-PWMSERVO, y el BUTTON. El circuito correspondiente es el siguiente:


Circuito 16-10
16.2 Actuadores AC
Para el uso de actuadores AC, se pueden usar esencialmente dos tcnicas, la primera es la
implementacin de relevadores con la limitacin de que solo pueden hacerse acciones de
conmutacin ON, OFF. Sin embargo se pueden implementar dispositivos en estdo solid como
los TRIAC, estos dispositivos permiten manipular cargas AC, y pueden regular su potencia
haciendo recorte de fase de la seal AC, que generalmente es de 60Hz. Los TRIAC son de fcil
implementacin y su uso puede hacerse aislando las corrientes de potencia con opt acopladores
como los MOC3011, 3010, 3021, etc. Los TRIAC se pueden adquirir en capacidad de la mxima
corriente que pueden soportar. Un TRIAC cuenta con tres terminales que son: A1, A2, y gate, los
TRIAC cortocircuitan las terminales A1, y A2, cuando una corriente circula entre el gate y A1. y
solo se desconecta cuando la corriente de A2 se hace 0, esto es cosible cuando la seal AC, hace
su cruce por cero.

La apariencia fsica y la vista en ISIS de estos dispositivos es la siguiente:


Figura 16-6

Como se puede observar en la grfica los MOC, son dispositivos que internamente tienen un
TRIAC, pero la corriente que pueden soportar es relativamente pequea, y a su vez lo
suficientemente grande para disparar otro TRIAC de mayor potencia. Tambin se puede observar
274
que la compuerta gate de los MOC, se activa por medio de la luz emitida por un LED, este
tambin est incorporado en el mismo encapsulado. En conclusin un TRIAC de gran potencia
puede ser activado por medio de un circuito digital con solo la activacin de un LED.
Para entender este arreglo de forma clara, se puede observar el siguiente circuito:


Circuito 16-11

Para lograr la regulacin de la potencia sobre una carga AC, se hace necesario hacer un recorte
sobre la fase, de la seal de poder seno. La red elctrica comercial tiene 120V AC, y una
frecuencia de 60Hz. Lo que indica que un siclo de la red elctrica dura 1/60, es decir 16,666m
segundos. El trabajo de recorte de la fase se debe hacer sobre cada medio siclo es decir en
8,333m segundos. Lo anterior indica que el recorte de fase se hace entre 0 y 180 grados, y se
repite igual entre 180 y 360 grados. Para comprender de forma clara este concepto se puede
observar la siguiente grfica:



Figura 16-7

275
Para poder realizar el recorte de fase, es indispensable detectar el cruce por cero de la seal seno,
para sincronizarse con ella. Para detectar el cruce por cero existen diversas estrategias, sin
embargo en el prximo ejemplo se mostrar una que implica la implementacin de opto
acopladores. El uso de opto acopladores es ideal para hacer un aislamiento elctrico de la etapa
de potencia con la etapa de electrnica de control. El siguiente programa usa un PIC 16F628A,
con frecuencia de reloj de 20MHz:

//Variables globales.
unsigned short PWM=41, CONT=0;

//Funcin de interrupciones.
void interrupt()
{
//Interrupcin externa por RB0.
if( INTCON.F1 )
{
//Se apaga el pin de disparo.
PORTB.F7=0;
//Se reinicia el contador.
CONT = 0;
//Se apaga la bandera de la interrupcin
//externa.
INTCON.F1=0;
}
//Interrupcin por Timer 0 a 102.4u Seg.
if( INTCON.F2 )
{
//Se incrementa el contador.
CONT ++;
//Se compara el contador con el punto,
//PWM, y se apaga el disparo y es mayor el contador.
if( CONT > PWM )PORTB.F7=1;
//Se apaga la bandera de la interrupcin por
//Timer 0.
INTCON.F2 =0;
}
}

void main( void )
{
//Configuracin de puertos.
TRISB = 0b01111111;
PORTB = 0;
//Activacin del Timer0, y flanco de
//interrupcin externa.
OPTION_REG = 0b01000000;
INTCON = 0b10110000;
while( 1 )// Bucle infinito.
{
276
//Pulsador de menor potencia.
while( Button( &PORTB, 1, 10, 0 ) )
{
//Decremento del recorte de fase.
PWM ++; if( PWM > 84 )PWM=84;
delay_ms(10); //Retardo de cambio.
}

//Pulsador de mayor frecuencia.
while( Button( &PORTB, 2, 10, 0 ) )
{
//Incremento del recorte de fase.
PWM --; if( PWM == 255 )PWM=0;
delay_ms(10); //Retardo de cambio.
}

}
}

Para realizar la simulacin de este ejercicio se implementa en ISIS los dispositivos: 16F628A,
RES, BUTTON, MOC3023, Q4006L4, B80C1000, OPTOCOUPLER-NPN, VSINE, y el
OSCILLOSCOPE. El circuito electrnico es el siguiente:


Circuito 16-12

Despus de correr la simulacin se puede apreciar en el osciloscopio virtual, la siguiente vista:

277

Figura 16-8

El canal A representa la seal sobre la carga de potencia y se puede apreciar sobre est, el recorte
de fase. El canal B, muestra un pico cuando la seal seno presenta su cruce por cero, este pico es
usado por el microcontrolador para sincronizarse con la red por medio de la interrupcin externa.
El canal C, muestra la seal de control que dispara el juego de TRIACs.
278

279
17 Anexos
17.1 Tabla ASCII


ASCII

Hex

Smbolo


0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F


NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
TAB
LF
VT
FF
(Enter)
SO
SI



ASCII

Hex

Smbolo


16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F


DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US



ASCII

Hex

Smbolo


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F


(Espacio)
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/



ASCII

Hex

Smbolo


48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


30
31
32
33
34
35
36
37
38
39
3A
3B
3C
3D
3E
3F


0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?



ASCII

Hex

Smbolo


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F


@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O



ASCII

Hex

Smbolo


80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95


50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F


P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_



ASCII

Hex

Smbolo


96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111


60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F


`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o



ASCII

Hex

Smbolo


112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127


70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F


p
q
r
s
t
u
v
w
x
y
z
{
|
}
~





280
281
Bibliografa

Behrouz A. Forouzan, Transmisin de datos y redes de comunicaciones, Segunda Edicin, Mc
Graw Hill, ISBN 84-481-3390-0.

Boylestd Robert, Electronica: Teoria de Circuitos, Sexta Edicion, PRENTICE HALL, ISBN
968-880-805-9.

Coughlin Robert, Amplificadores operacionales y circuitos integrados lineales, Quinta Edicion,
PRENTICE HALL, ISBN 970-17-0267-0.

Dorf Richard, CIRCUITOS ELECTRICOS Introduccin al Analisis y Diseo, Tercera Edicion,
Alfaomega, ISBN 970-15-0517-4.

Galeano Gustavo, Programacin de Sistemas Embebidos en C, Primera Edicion, Alfaomega,
ISBN 978-958-682-770-6.

Ogata Katsuhiko, Ingenieria de Control Moderna, Tercera Edicion, PRENTICE HALL, ISBN
970-17-0048-1.

M. Morris Mano, Logica Digital y Diseo de Computadores, Primera Edicion, PRENTICE
HALL, ISBN 968-880-016-3.

Oppenheim Alan, Seales y Sistemas, Segunda Edicion, PEARSON PRENTICE HALL, ISBN
970-17-0116-X.

Proakis John, Tratamiento digital de seales, Cuarta Edicion, PEARSON PRENTICE HALL,
ISBN 978-84-8322-347-5.
282
283
ndice
1
16F628A 58, 162, 166, 176, 264, 265, 266, 268, 270, 273,
275, 276
16F84A 39, 46, 47, 49, 52, 58
16F877A 65, 71, 75, 77, 79, 89, 94, 110, 113, 118, 120,
121, 123, 124, 126, 129, 130, 133, 137, 140, 146, 170,
174, 189, 241
18F2550 88, 95, 96
18F452 71, 150, 159, 181, 202, 229, 231
18F4550 88, 95
18F4585 234, 238
2
24LC00 89
7
74LS04 176
A
ACK 88, 141, 143, 244, 245, 246, 247, 248, 249, 250,
251, 256, 257, 259, 260, 279
acknowledge 88
Actuadores AC 273
Actuadores DC 262
Actuadores y potencia 262
AD 109, 128, 129, 132, 136, 139, 202
ADC 17, 109, 124, 128, 129, 130, 133, 136, 137, 140,
173, 203, 206, 216, 218, 223, 230, 236
ADC_Read 109
ADCON1 90, 129, 136
AND 25, 26, 27, 30, 177
Anexos 279
ASCII 20, 21, 50, 54, 59, 60, 61, 85, 86, 87, 94, 95, 126,
149, 175, 244, 279
ASK 161, 174, 175
B
Bibliografa 281
bilineal 212, 213, 219, 221, 239
bit 20, 21
BJT 262, 263
Button 74, 76, 91, 173, 264, 266, 269, 272, 276
BUTTON 35, 37, 75, 79, 89, 118, 126, 166, 174, 231,
265, 269, 270, 273, 276
ByteToStr 59, 80, 189
C
CAP 113, 174, 231
Caractersticas bsicas del ISIS para simular 35
Ch
char 20, 21
C
COM 47, 167
COMPIM 159
Comunicacin con dispositivos 147
Comunicacin con memorias SD 177
Comunicacin RS 485 172
Comunicaciones seriales 88
Condicionales e iteraciones en lenguaje C 30
Control de display de 7 segmentos 45
Control de displays 7 segmentos dinmicos 47
Control de errores 252
Control digital PID 238
Conversin AD y DA 109
Conversin AD, o ADC 109
Conversin DA con arreglo R-2R 114
Conversin DA con PWM 110
Conversin DA o DAC 110
Convolucin 192
coordenadas 55, 72, 73, 148, 149, 151, 153, 155, 158
CRC 252, 253, 254, 255, 256, 257, 258, 260
Creacin de caracteres propios 59
Creacin de condiciones lgicas en lenguaje C 30
Creacin de un programa en lenguaje C 29
Creacin del primer programa en MikroC PRO 38
cruce por cero 273, 275, 277
D
DA 110, 114, 203
DB9 92
Declaracin de variables en lenguaje C 20, 244, 247, 252
Definit.h 99, 100
delay_ms 46, 47, 48, 73, 91, 99, 130, 133, 137, 140, 142,
144, 145, 164, 165, 173, 176, 184, 185, 189, 264, 272,
276
delay_us 46, 113, 116, 142, 163, 164, 272
DIN 84
Dip-Switch 76, 77, 78
display 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 64, 65, 70,
73, 79, 83, 87, 154, 158, 159
Display de 7 segmentos 44
Display LCD de caracteres 50
Display LCD grficos 64
284
double 20, 21
DS1307 183, 184, 189
DTF 228
E
EEPROM 117, 118
EEPROM_Read 117
EEPROM_Write 117
Ejemplo de diseo filtro rechaza banda 222
Ejemplo de diseo oscilador doble cuadrado 225
Ejemplo de diseo para filtro multi banda 210
Ejemplo de diseo para filtro pasa altas 207, 217
Ejemplo de diseo para filtro pasa bajas 204, 215
Ejemplo de diseo para filtro pasa banda 208, 220
Ejemplo de diseo para filtro rechaza banda 209
Ejemplo de diseo para oscilador de acople en cuadratura
226
Ejemplos de diseo para filtros FIR 202
El autor 11
El ciclo iterativo for 33
El ciclo iterativo while y do while 32
El compilador MikroC PRO 18
El microcontrolador PICMicro 17
El simulador ISIS de Proteus 34
ENQ 246
EOT 244, 245, 246, 247, 249, 250, 251, 257, 260, 279
F
FFT 232, 233, 234, 235, 237
Filtro Multi Band 196
Filtro Pasa Altas IIR 216
Filtro Pasa Bajas IIR 213
Filtro Pasa Banda 194
Filtro Pasa Banda IIR 219
Filtro Rechaza Banda 195
Filtro Rechaza Banda IIR 221
Filtros FIR 192
Filtros IIR 212
Filtros Pasa Altas 194
FIR 191, 192, 193, 196, 197, 202, 212, 213, 215, 226, 229
FLASH 117, 118, 119, 120
FLASH_Read 119, 120
FLASH_Write 118, 120
float 20, 21
FloatToStr 58, 146, 154, 157, 158, 237
Formatos numricos usados en el lenguaje C 23
FSK 161
funcin de transferencia 131, 134, 135, 136, 137, 191,
193, 194, 195, 197, 205, 212, 214, 219, 221, 239
Funciones de transferencia 191
Funciones en lenguaje C 27
Funciones para imprimir cadenas de texto 55
Funciones para imprimir caracteres 54
Fundamentos de lenguaje C 20, 243
G
Gibbs 197, 198, 199, 200, 201, 202
GIE 124, 125
GLCD 65, 66, 67, 69, 71
GLCD Bitmap Editor 66
Glcd_Box 72, 73
Glcd_Circle 72, 73
Glcd_Dot 72, 73
Glcd_Fill 70, 71, 73
Glcd_Init 65, 70, 73
Glcd_Line 72, 73
Glcd_Rectangle 72
GP2D12 134, 137
GPS 88, 147, 148, 149, 152, 160, 161
GROUND 36
H
HID 88, 98, 99, 100, 101, 103, 104, 105, 107, 108
HID Terminal 100, 107
Hid_Disable 99
Hid_Enable 98, 99
Hid_Read 99
Hid_Write 99
I
I2C 17, 88, 90, 184, 189
IC 88, 141, 183
I2C1_Init 88, 90, 184
I2C1_Is_Idle 88
I2C1_Rd 88, 90, 184, 185, 186
I2C1_Repeated_Start 88, 90, 184, 185, 186
I2C1_Start 88, 90, 91, 183
I2C1_Stop 89, 91, 184, 185, 186
I2C1_Wr 89, 90, 91, 183, 184, 185, 186
I2CDEBUGGER 89
IEEE 801.15.4 167
IIR 191, 212, 215, 226, 229, 239
Impresin de valores numricos 57
infrarrojos 174, 176
int 20, 21
I NTCON 98, 124, 125, 126, 150, 158, 203, 204, 206, 216,
218, 219, 223, 224, 226, 227, 228, 230, 231, 236, 237,
275
INTE 124, 125
Interrupciones 124
INTF 100, 103, 104, 124, 125
Introduccin 15
IntToStr 57, 58, 130, 133, 137, 153, 156, 157, 159, 237
IRLINK 175, 176
ISIS 1, 5, 34, 35, 37, 40, 47, 49, 50, 52, 57, 61, 63, 64, 65,
71, 73, 75, 76, 77, 79, 84, 89, 91, 94, 96, 110, 116, 118,
120, 123, 126, 128, 130, 131, 133, 134, 137, 138, 140,
141, 146, 147, 159, 160, 161, 167, 175, 176, 181, 183,
189, 202, 203, 231, 238, 262, 263, 265, 267, 269, 270,
271, 273, 276
K
Keypad_Init 79
Keypad_Key_Click 79
Keypad_Key_Press 79, 80, 82, 83
285
L
L293D 241, 270
La sentencia condicional if e if else 31
La sentencia switch case 32
LCD 44, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63,
64, 65, 71, 72, 73, 80, 82, 83, 86, 87, 129, 132, 136, 137,
139, 140, 146, 154, 158, 159, 169, 170
LCD Custom character 60
Lcd_Chr 54, 55, 59, 83, 87
Lcd_Chr_Cp 54, 55, 59
Lcd_Cmd 64, 80, 83, 87, 129, 132, 137, 140, 146, 158
Lcd_Init 51, 52, 54, 55, 56, 57, 58, 61, 63, 80, 83, 87, 129,
132, 136, 140, 146, 158, 169
Lcd_Out 55, 56, 57, 58, 80, 83, 87, 129, 130, 132, 133,
137, 140, 146, 158, 159, 170
Lcd_Out_Cp 55, 57
LDR 138, 139, 140
LED 35, 44, 75, 77, 89, 96, 110, 118, 126, 166, 189, 231,
274
Library Manager 51
LM35 128, 130, 131
long 20, 21
LongToStr 59, 140, 180, 181
LongWordToStr 59
M
main 29, 30, 39, 46, 48, 49, 52, 54, 55, 56, 57, 58, 61, 63,
65, 70, 72, 75, 76, 77, 80, 83, 84, 87, 90, 94, 98, 109,
112, 115, 117, 119, 122, 124, 126, 129, 132, 136, 139,
145, 150, 158, 165, 166, 169, 172, 175, 178, 188, 204,
206, 216, 219, 223, 226, 228, 231, 237, 264, 266, 268,
272, 275
matriz de rotacin 224, 225, 227
MAX232 93
MAX485 172, 173, 174
MAX487 174
MCLR 40
Memoria EEPROM 117
Memoria FLASH 118
Memorias EEPROM y FLASH 117
MikroC PRO 1, 5, 13, 15, 18, 20, 38, 45, 50, 51, 59, 62,
65, 66, 71, 72, 74, 79, 80, 84, 88, 89, 93, 96, 98, 99, 109,
112, 117, 124, 177, 190
Mmc_Init 178
Mmc_Read_Sector 178, 181
Mmc_Write_Sector 178, 181
MOC3011 273
MODEM 167
Mdulo de acople con un ordenador personal 168
Modulo serial IC 88
Mdulo USART 91
Mdulo USB 95, 108
Mdulos GPS 147
Mdulos inalmbricos bidireccionales 167
Mdulos inalmbricos infrarrojos 174
Mdulos inalmbricos unidireccionales 161
Mdulos Timer 121
MOSFET 262, 263
MOTOR 265, 269, 270, 273
motor unipolar 267, 268, 270
Motores AC 262
motores bipolares 270
Motores DC 264
Motores Paso 267
MPX4115 131, 133
Muestreo 190
N
NAK 244, 245, 246, 247, 248, 249, 250, 257, 259, 260,
261, 279
NOT 25, 26, 30
Nyquist 190
O
Operadores en lenguaje C 23
OPTI ON_REG 122, 126, 165, 173, 264, 266, 268, 272,
275
opto acopladores 275
OR 25, 26, 27, 30
Osciladores digitales 224
OSCILLOSCOPE 113, 123, 126, 202, 276
P
PICMicro 17, 18, 34, 38, 109, 190
PID 99, 103, 238, 239, 241
PI E1 98, 124, 125, 126, 150, 158
PI E2 98, 124, 125, 126, 150, 158
PI R1 98, 124, 125, 126, 150, 157, 158
PI R2 98, 124, 126, 150, 158
PLL 98, 202
PORTA 48, 49, 90, 91
PORTB 30, 39, 40, 46, 48, 75, 76, 77, 90, 91, 98, 99, 109,
115, 116, 117, 119, 122, 125, 126, 158, 165, 166, 172,
173, 203, 204, 206, 216, 219, 223, 224, 226, 228, 231,
237, 264, 266, 268, 269, 272, 275, 276
POWER 36, 100
Prologo 13
PS2 74, 84, 86, 122
Ps2_Config 84
Ps2_Key_Read 84, 87
Puente H 265
PULL-UP 165, 173, 174, 264, 266, 268, 272
PWM 17, 109, 110, 111, 112, 113, 114, 115, 116, 162,
173, 175, 176, 264, 271, 272, 275, 276
PWM1_Init 112, 173, 175, 264
PWM1_Set_Duty 112, 113, 173, 176, 264
PWM1_Start 112, 173, 175, 264
PWM1_Stop 112
R
R-2R 114, 203
RAM 18, 59, 63, 103, 177, 234
RCIE 124, 125
RCIF 124, 125
recorte de fase 273, 274, 275, 276, 277
Relevadores 263
286
reloj 84, 88, 91, 98, 121, 141, 142, 143, 145, 159, 162,
178, 183, 188, 189, 202, 241, 268, 273, 275
Relojes en tiempo real 183
RES 35, 47, 49, 75, 77, 79, 89, 96, 110, 113, 118, 126,
130, 137, 140, 146, 166, 174, 176, 189, 202, 231, 265,
276
RS 485 172
RS232 34, 92, 93
S
SD 88, 105, 177, 178, 179
Sensor de temperatura LM35 128
Sensores 128
Sensores de distancia 134
Sensores de humedad y temperatura 141
Sensores de presin 131
Sensores LDR 138
Servomotores 271
short 20, 21
ShortToStr 59
SHT71 146
SHT7x 141, 145, 146
SPI 88, 177, 178, 181
SPI1_Init_Advanced 178, 181
switch case 30, 32, 82, 83
T
teclado 18, 78, 79, 80, 81, 82, 83, 84, 86, 87
Teclados y sistemas de entrada de datos 74
Timer 17, 121, 122, 125, 126, 275
Timer 0 121, 122
TMR0IE 124, 125
TMR0IF 124, 125
Transformacin bilineal 213
Transformada discreta de Fourier DFT 228
Transformada rpida de Fourier FFT 232
Transmisin 243
Tratamiento digital de seales 190
TRIAC 273
TRISA 49
TRISB 30, 39, 40, 46, 49, 75, 76, 77, 90, 98, 109, 115,
117, 119, 122, 126, 158, 165, 166, 172, 204, 206, 216,
219, 223, 226, 228, 231, 237, 266, 268, 272, 275
TRISE 90
TTL 172
typedef struct 22
U
UART1_Data_Ready 93, 95, 119, 170, 173, 179, 180, 181
UART1_Init 93, 94, 119, 126, 150, 158, 169, 173, 175,
178, 189, 237
UART1_Read 93, 95, 119, 126, 150, 157, 170, 173, 179,
180, 181
UART1_Read_Text 93
UART1_Tx_Idle 93
UART1_Write 93, 94, 95, 119, 120, 126, 170, 173, 176,
178, 179, 180, 181, 189, 237
UART1_Write_Text 94, 95, 119, 120, 126, 170, 176, 178,
179, 180, 181, 189, 237
unsigned char 21
unsigned int 21
unsigned long 21
unsigned short 21
USART 17, 18, 58, 88, 91, 93, 94, 124, 149, 169, 172,
173, 175, 189
USB 18, 34, 88, 95, 96, 98, 99, 100, 101, 102, 103, 105,
107
USBCONN 96
USBdsc.c 99, 107
Uso anidado de ciclos iterativos 33
Uso de Dip-Switch 76
Uso de pulsadores 74
Uso de teclados matriciales 78
Uso de teclados PS2 o Din 84
V
variable compleja 191, 212
VARs.h 99, 104
Ventanas Blackman 201
Ventanas fijas 196
Ventanas Hamming 198
Ventanas Hanning 199
Ventanas Rectangulares 197
VIP 99
VIRTUAL TERMINAL 94, 120, 126, 170, 176, 181, 189,
238
Visualizacin de datos 44
VSINE 276
VUSB 96
W
WordToStr 59
www.digi.com 167
www.labcenter.com 34
www.mikroe.com 18
www.virtual-serial-port.com 147
X
XBee 88, 167, 169
XBee PRO 167
X-CTU 167, 169
Z
Zigbee 169


287

288

289