XIII MUSTRA TECNOLOGICA Y

XII SEMINARIO TALLER DE

INSTRUMENTACIN Y
CONTROL
MINI CURSO:
APLIQUEMOS C CCS Y
PROTEUS EN
MICROCONTROLADORES PIC

DOCENTE:

EDWARD MARN GARCA

INGENIERO Y TECNLOGO ELECTRNICO
MAGISTER EN INGENIERA ELCTRICA.

MINI CURSO:
APLIQUEMOS C CCS Y
PROTEUS EN
MICROCONTROLADORES PIC

EL MINI CURSO INCLUYE:

Libreta de apuntes conmemorativas al XIII
seminario taller y XII muestra tecnolgica.
Presentacin del mini curso.
Aplicaciones simuladas en el mini curso.
Instalador para compilador C CCS (opcional).
Instalador simulador proteus (opcional).
Archivo con instrucciones para el manejo del
compilador C CCS.

HERRAMIENTAS
Compilador PIC C.
PCW

Simulador PROTEUS.
ISIS profesional

Documentos de trabajo con ejemplos, ejercicios

y simulaciones.

COMPILADORES PARA PIC

PROGRAMACION EN LENGUAJES DE BAJO NIVEL:
Cdigos en lenguaje de maquina. (0 1). En paquetes
de bits.
PROGRAMACIN EN LENGUAJES DE ALTO NIVEL:
Utiliza programas independientes a la plataforma
utilizada por los dispositivos.
Algunos programas son: BASIC, FORTRAN, PASCAL y
C.

DIFERENCIAS
DESCRIPCIN

ENSAMBLADOR

LENGUAJE C

Facilidad de programacin.

Tiempos de desarrollo menor.

Portabilidad entre sistemas.

Desarrollos de programas
estructurados.

Fuertemente dependiente al hardware

Menor numero de instrucciones para

generar una tarea.

Mayor velocidad de ejecucin.

Reducido numero de instrucciones

COMPILADORES DE C PARA PIC

Para la eleccin del compilador se deben tener
en cuenta los siguientes factores:
Optimizacin del cdigo generado.
Dispositivos para los que compilador es capaz
de generar cdigo.
Funciones y directivas definidas.
Posibilidades adicionales como insercin de
cdigo ensamblador

Precio.

SOFTWARE USADO
MPLAB C18 (Microchip): usado para PIC de 8 bits.
MPLAB C24 (Microchip): usado para PIC de 16 bits y
dsPIC.
MPLAB C32 (Microchip): usado para PIC de 32 bits,
PIC gama alta.
PICC (Hi Tech): soporte para gama de 24 y 32 bits.
Muy reservado por los fabricantes.

PCW compiler:
MikroC: compilador liviano. Bsico para iniciar a trabajar
con los PIC.
MPC, CC5X, SDCC compiler

COMPILADOR C CCS
INTRODUCCIN
Desarrollado
especficamente
para
PIC,
obteniendo la mxima optimizacin del compilador
con esos dispositivos.
Es un compilador que convierte el lenguaje de alto
nivel en cdigo de maquina.

COMPILADOR C CCS
CARACTERSTICAS
Amplia librera de funciones predefinidas.
Comandos de preprocesado.
Suministra los controladores para:
LCD.
Convertidores AD.
Relojes en tiempo real.
EEprom.

COMPILADOR C CCS
CARACTERSTICAS
Adems contiene:
Directivas estndar (#include, etc).
Directivas especficas para PIC (#device, etc).
Funciones especficas (bit_set(), etc)

INICIAMOS CON LA FORMA DE

PROGRAMACION CON EL
COMPILADOR C CCS PARA
MICROCONTROLADORES PIC
SIGAMOS LA PRESENTACIN
DETALLADAMENTE

ENTORNO DE TRABAJO
Existen tres compiladores bsicos:
PCB: usado en PIC de 12 bits.
PCM: usado en PIC 14 bits.
PCH: usado para PIC 16 bits.
Incluye compiladores con windows IDE (PCW y
PCWH).
Los ficheros utilizados son: C, H, PJT, HEX,
COF

ENTORNO DE TRABAJO

COMO CREAR UN PROYECTO?

COMO CREAR UN ARCHIVO FUENTE?

ENTORNO DEL ARCHIVO FUENTE

CREA PROYECTO MANUAL

SELECCION DEL MICROCONTROLADOR

A TRABAJAR

OJO!!!!!!
DIRECTIVAS, FUNCIONES
E INSTRUCCIONES
USADAS EN C CCS

Para escribir un programa en C en CCS se

debe tener en cuenta la siguiente estructura:
Directivas de preprocesado: controlan la conversin
del programa a cdigo mquina por parte del
compilador.
#include<16f877.h>
Programas o funciones: conjunto de instrucciones.
void main()
Instrucciones: Indica el comportamiento del PIC en
todo momento.
eneable_interrupts(global);

Comentarios: permite describir lo que significa cada

lnea.
// habilita interrupcin general

VARIABLES Global - Local

Se utilizan para nombrar posiciones de memoria.
Pueden ser de tipo LOCAL o GLOBAL.

OPERADORES
ASIGNACION:

OPERADORES
ARITMETICOS

OPERADORES
RELACIONALES - LOGICOS

OPERADORES
DE BITS - PUNTEROS

FUNCIONES EN C
Las funciones pueden devolver valores a las
sentencias que la invocan, indicando el tipo de dato.
En caso que no se requiera devolver valores se debe
especificar con el valor VOID.

Las funciones pueden agruparse en ficheros de

libreras <fichero.h>, que se pueden utilizar mediante la
directiva #include<fichero.h>

DIRECTIVAS
comienzan
con el smbolo
# y continan
con
un
comando
especfico.

COMO LAS EMPLEAMOS?

#DEVICE chip: permite definir el PIC a utilizar.
#device PIC16f877
#FUSES options: define la palabra de configuracin
para programar un PIC.
#device PIC16f877
#fuses XT, NOWDT
#INCLUDE filename: permite incluir el fichero en el
programa.
#include<16f877>
#USE DELAY (CLOCK=SPEED): define la frecuencia
del oscilador del PIC.
#include<16f877>
#use delay(clock=4000000)

FUNCIONES PREDEFINIDAS EN C CCS

C CCS posee
funciones
predefinidas
para usar el
PIC y sus
perifricos.

LISTO!!!
EMPECEMOS A CAMELLAR

MANEJO DE PUERTOS
Se pueden gestionar de dos formas:
Definiendo su posicin de memoria en
RAM.
#byte variable = cte;
Usando las directivas especficas del
compilador.
#use fast_io(), #use fixed_io(),
#standard_io().

PRIMERA FORMA
Accediendo a la RAM usando
declaracin de registros en C.

la

#BYTE TRISB = 0x86;

#BYTE PORTB = 0x06;
Despus de declaradas, pueden ser usadas por medio
de asignaciones sencillas en C:
TRISB = 0x00;
PORTB = 0Xff;

//Puerto B como salida

//Pines del puerto B activos

FUNCIONES RELACIONADAS
El uso de estas directivas debe venir
acompaado de algunas funciones especficas
del compilador como son:
output_x(valor);
//saca el valor por el puerto.
input_x();
//obtiene el valor del puerto.
set_tris_x(valor); //carga el registro TRIS con valor.
port_b_pullups(TRUE/FALSE);

FUNCIONES RELACIONADAS
O con funciones para el manejo de los bits:
bit_clear(variable,bit);
//0 en bit de variable.
bit_set(variable,bit);
//1 en bit de variable.
bit_test(variable,bit);
//muestra el bit de variable.
swap(variable);
//intercambio de bits.
O con funciones definidas a los terminales:
output_low(pin definido);
//pin definido en 0.
output_high(pin definido);
//pin definido en 1.
output_bit(pin definido,valor); //pin a valor.
output_toggle(pin definido);
//invierte pin.
input(pin definido);

//lee el pin

APLICACION 1

Desarrollar un sistema que permita prender y

apagar dos LEDs, a manera de complemento,
en donde, el primero encienda y el segundo
apague, usando como mando un suiche.

#include <16f887.h>
#use DELAY (clock = 4000000) //reloj 4 MHz
#FUSES XT, NOWDT
//definicin de registros por RAM
#BYTE TRISA = 0x85
#BYTE PORTA = 0x05
#BYTE TRISB = 0x86
#BYTE PORTB = 0x06
#BYTE OPTION_REG = 0x81

//programa principal
void main(){
//habilitar pull-up
bit_clear(OPTION_REG,7);
//pines como entrada / salida
bit_set(TRISB,0);
//B0 entrada
bit_clear(TRISB,1);
//B1 salida
bit_clear(TRISA,0);
//A0 salida

//ciclo infinito de ejecucin

while(1){
//prendo/apago LEDs
if(bit_test(PORTB,0) == 1){
bit_set(PORTB,1);
bit_clear(PORTA,0);}
//prendo/apago LEDs
else{
bit_clear(PORTB,1);
bit_set(PORTA,0);}
}
}

SIMULACION

AHORA MANEJEMOS
DISPLAY LCD.
TECLADOS MATRICIALES.

COMO MANEJO UN DISPLAY

LCD?
El compilador C CCS tiene un driver que
permite manipular los LCD.
El archivo es LCD.C y debe llamarse
como:

#include <lcd.c>

FUNCIONES RELACIONADAS
Funciones definidas para el manejo de LCD:

lcd_init();

//primera funcin que debe ser llamada.

//Qu hace?
//borra LCD - configuracin a 4 bits doble
lnea modo //encendido cursor apagado y
sin parpadeo autoincremento //de puntero de
direcciones sin desplazamiento real.

OTRAS FUNCIONES RELACIONADAS

lcd_gotoxy(x,y);
lcd_getc(x,y);
lcd_putc(s);

//posicin en LCD (x,y).

//lee carcter en posicin (x,y).
//escribe variable tipo char.

Tambin se tiene las siguientes funciones:

\f
\n
\b

//limpia LCD.
//cursor salta de lnea.
//cursor retrocede.

Adems:
printf(string);
printf(cstring, values);
printf(fname, cstring, values);
//string es una cadena o arreglo de caracteres, values es una lista
de variables, fname es una funcin.

El formato utilizado es %nt, cuya indicacin lo

muestran las siguientes tablas:
n puede ser:
1-9

indicacin
Cuantos caracteres.

01 09

Cantidad de ceros a la izquierda.

1.1-9.9

Coma flotante.

t puede ser:
c
s
u
d
Lu
Ld
x
X
Lx
LX
f
g
e
w

indicacin
caracter
Cadena o carcter
Entero sin signo.
Entero con signo.
Entero largo sin signo
Entero largo con signo
Entero hexadecimal (minscula).
Entero hexadecimal (mayscula).
Entero largo hexadecimal (minscula).
Entero largo hexadecimal (mayscula).
Flotante con truncado.
Flotante con redondeo
Flotante en formato exponencial.
Entero sin signo con decimales
insertados.

COMO CONECTO LA LCD AL

MICROCONTROLADOR?
Por defecto se usa el PORTD, pero en caso que
se requiera usarlo en el PORTB, se debe
acceder directamente al driver de la LCD y se
comenta la instruccin:

//#define use_portb_lcd TRUE

LIBRERIA LCD

APLICACION 2

Desarrollar un sistema que permita visualizar

en display LCD el resultado de una operacin
matemtica y obtener los resultados en
decimal y hexadecimal, cambiando los
resultados por medio de un mando externo
ingresados por el PORTA.

#include <16f887.h>
#fuses XT, NOWDT
#use delay (clock = 4000000)
#include <LCD.C>
#BYTE TRISA = 0x85 //definicin de registros por RAM.
#BYTE PORTA = 0x05
int i=0, resultado;

//declaracin de variables globales

void decimal();
void hexa();

//declaracin de funciones.

void main(){ //programa principal

int valor1=3, valor2=17;

//declaracin de variable de operacin

lcd_init();

//inicializacin de LCD

bit_set(TRISA,0);
resultado = valor1 + valor2;
//ciclo infinito de ejecucin
while(1){

//A0 entrada
//operacin

//ciclo infinito de ejecucin

while(1){
//men principal
lcd_gotoxy(1,1);
printf(lcd_putc, "INICIO OPERACION");
lcd_gotoxy(1,2);
printf(lcd_putc, "SELECCIONE...");

//pregunta por pulso de mando externo PORTA

if(bit_test(PORTA,0) == 1){
if(i == 0){
delay_ms(300); //anti rebote
decimal();}
}
if(bit_test(PORTA,0) == 1){
if(i == 1){
delay_ms(300); //anti rebote
hexa();}
}

//funcin para resultado decimal

void decimal(){
lcd_gotoxy(1,1);
printf(lcd_putc, "\fRESUL DECIMAL:%u\n", resultado);
delay_ms(1000);
i++;
}
//funcin para resultado hexadecimal

void hexa(){
lcd_gotoxy(1,1);
printf(lcd_putc, "\fRESUL HEXA:%x\n", resultado);
delay_ms(1000);
i=0;
}

SIMULACION

COMO MANEJO UN TECLADO

MATRICIAL?
Este compilador tiene incluido en sus libreras,
el driver KBD.C, usado para el manejo de
teclados matriciales de 3 x 4.

#include <kbd.c>

FUNCIONES DEFINIDAS PARA EL

MANEJO DEL TELADO MATRICIAL
kbd_init(); //primera funcin que debe ser llamada.
kbd_getc ();
//retorna valor de tecla pulsada.
COMO CONECTO UN TECLADO
MICROCONTROLADOR?

MATRICIAL

AL

Este archivo viene por defecto para trabajar por el

PORTD, pero en caso de requerir el manejo del
dispositivo por el PORTB, se debe desactivar la
siguiente instruccin del driver utilizado:

#define use_portb_kbd TRUE

APLICACION 3

Desarrollar un sistema que permita ingresar una clave de tres

dgitos por medio de un teclado matricial de 3 x 4. Visualizar el
carcter * cuando se van ingresando los datos en un display
LCD de 2 x 16. El usuario en caso de ingresar los datos mal, en la
pantalla aparecer un mensaje <<calve incorrecta>>, en caso de
acertar con la clave, aparecer el mensaje <<clave correcta>>, e
inmediatamente encender un LED.

#include <16F877.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock= 4000000)
#include <lcd.c>

//llamada a librera del LCD

#include <kbd.c>

//llamada a librera de teclado.

char valido[3]={'1','2','3'};

//clave valida

void main() {

//programa principal

char k;
int i, a, b;
char data[3], clave[3];

//variables guardar clave y datos

kbd_init();
//inicializa teclado
lcd_init();
//inicializa LCD
port_b_pullups(TRUE); //activa resistencias de pull up

while (TRUE) {
i=0; a=2; b=3;

//ciclo de ejecucin infinito

printf(lcd_putc,"\fnumero 1\n");
while(i<=2){
k=kbd_getc();
if (k!=0) {
data[i]=k;
i++;

//Para primer dato

//corrimiento de tres datos

//Lee el teclado
//Si se ha pulsado alguna tecla
//se guarda en la posicin correspondiente

printf(lcd_putc,"\fnumero %u\n",i+1);
lcd_gotoxy(1,2);
printf(lcd_putc, "*");
lcd_gotoxy((a-1),2);
printf(lcd_putc, "*");
lcd_gotoxy((b-2),2);
printf(lcd_putc, "*");

//Siguiente dato

//visualiza caracter '*'

//visualiza caracter '*'
//visualiza caracter '*'

a++;
b++;
}
}

for (i=0;i<=2;i++) {
clave[i]=valido[i]; }

//Clave valida

//Compara los datos con la clave

if ((data[0]==clave[0])&&(data[1]==clave[1])&&(data[2]==clave[2])){
//datos correctos!!!
printf(lcd_putc,"\fClave correcta");
output_high(PIN_A0);
//activa LED
delay_ms(1000);
output_low(PIN_A0);
//desactiva LED
}
else
//datos incorrectos!!!
printf(lcd_putc,"\fClave incorrecta");
delay_ms(1000);
}
}

//Clave incorrecta

SIMULACION

OTRA VENTAJA
Otra ventaja que ofrece el compilador C CCS
para el manejo de teclados matriciales es que
estos se pueden trabajar con los display LCD
en el mismo puerto, permitiendo la
disminucin de pines a la hora de alguna
aplicacin especial.
NOTA: esto se puede realizar siempre y
cuando no requiera el manejo de las
interrupciones externas por RB4 RB7.

APLICACION 4

Desarrollar un sistema que permita visualizar

en un display LCD de 2 x 16, la palabra
correspondiente a la tecla presionada. Use el
mnimo de pines posible.

#include <16F877.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock= 4000000)
#include <lcd.c>
#include <kbd.c>
void main() {
char k;
int x;
lcd_init();
kbd_init();
port_b_pullups(TRUE);

//funcin principal
//declaracin de variables

//inicializacin de LCD.
//inicializacin de teclado.
//resistencias de pullups activas

lcd_putc("\fOprima tecla...\n");
//ciclo de ejecucion infinito
while (TRUE) {
k=kbd_getc();
//lectura de teclado
x=k-48;
//Conversin numrica
if(k! =0){
//pregunta por la tecla presionada y visualiza su nombre

if(k=='1')
printf(lcd_putc,"\fUNO");
if(k=='2')
printf(lcd_putc,"\fDOS");
if(k=='3')
printf(lcd_putc,"\fTRES");
if(k=='4')
printf(lcd_putc,"\fCUATRO");
if(k=='5')
printf(lcd_putc,"\fCINCO");
if(k=='6')
printf(lcd_putc,"\fSEIS");

if(k=='7')
printf(lcd_putc,"\fSIETE");
if(k=='8')
printf(lcd_putc,"\fOCHO");
if(k=='9')
printf(lcd_putc,"\fNUEVE");
if(k=='0')
printf(lcd_putc,"\fDIEZ");
if(k=='*')
printf(lcd_putc,"\fASTERISCO");
if(k=='#')
printf(lcd_putc,"\fNUMERAL");
delay_ms(1000);
lcd_putc("\fOprima tecla...\n");

SIMULACION

AHORA MANEJEMOS
LA INTERRUPCION
EXTERNA RB0/INT.

LA INTERRUPCION EXTERNA RB0

La fuente de interrupciones externa INT/RB0 es muy
importante para atender eventos externos en tiempo
real. Cuando la lnea RB0/INT se hace una peticin de
interrupcin el bit INTF del registro INTCON se pone a
1 de forma automtica y, si el bit GIE est a 1, se
pone en marcha el mecanismo ya comentado de la
interrupcin.

LA INTERRUPCION EXTERNA RB0

Mediante el bit INTDEG del registro OPTION_REG es
seleccionado el flanco activo de RB0/INT, ya que con
ste puesto a 1 el flanco activo es el ascendente y
cuando est a 0 el flanco activo es el descendente. El
programa de atencin a la interrupcin antes de
regresar al programa principal debe borrar el flag INTF,
puesto que en caso contrario al ejecutar la instruccin
de retorno de interrupcin RETFIE se volver a
desarrollar el mismo proceso de interrupcin.

COMO TRABAJO CON LA INTERRUPCION

EXTERNA RB0?
Si se utilizan las directivas de interrupcin, el
compilador genera el cdigo necesario para
ejecutar la funcin que sigue a la directiva.
Adems genera el cdigo necesario para
guardar al principio y restituir al final el
contexto; tambin borrara el flag activo por la
interrupcin.

#INT_EXT

FUNCIONES DEFINIDAS
enable_interrupts(aplicacion); //habilita interrupcin.
desable_interrupts(aplicacion); //deshabilita interrupcin.
aplicacin es un constante definida en el fichero de cabecera
#include<16F87x.h>
Enable_interrupts(aplicacion)

INTCON

GLOBAL
INT_EXT

11000000 C0h
00010000 10h

Adems se pueden utilizar las siguientes funciones:

ext_int_edge(H_TO_L);
ext_int_edge(L_TO_H);

//interrupcin por flanco de bajada.

//interrupcin por flanco de subida.

APLICACION 5

Desarrollar un sistema que permita encender

un LED durante 1 segundo cuando se
produzca una pulsacin originada en el pin
RB0.

#include <16F887.h>
#fuses XT, NOWDT, PUT, NOWRT
#use delay(clock= 4000000) //frecuencia de reloj
#BYTE TRISB = 0x86
#BYTE PORTA = 0x06

//definicin de registros

#INT_EXT

//directiva de interrupcin por cambio en RB0

ext_isr(){
output_high(PIN_B1);
delay_ms(1000);
output_low(PIN_B1);
}

//Funcin de interrupcin
//enciende LED
//tiempo de 1 segundo
//Apaga LED

void main() {
bit_set(TRISB,0);
bit_clear(TRISB,1);

//B0 entrada
//B1 salida

output_low(PIN_B1);
port_b_pullups(TRUE);

//Apaga LED
//Pull-up para RB0

enable_interrupts(INT_EXT);
ext_int_edge(L_TO_H);
enable_interrupts(GLOBAL);

//Habilita interrupcin RB0.

//flanco de subida
//Habilita interrupcin global

while (1){
}
}

//Programa principal

//ciclo de ejecucin infinito

SIMULACION

AHORA MANEJEMOS

EL TMR0

EL CONTADOR/TEMPORIZADOR
TMR0
Los TIMERs interrumpen la ejecucin del programa
cuando los registros vinculados a estos, se desbordan,
es decir, reinician su conteo despus de llegar al
mximo del valor. El mximo valor depende del tamao
de este.

El TMR0 tiene asociado un registro de 8 bits.

Los registros asociados son:
OPTION_REG: configura el hardware.
INTCON: permite trabajar con la interrupcin.
TRISA: habilita la patita RA4.

EL CONTADOR/TEMPORIZADOR
TMR0
El registro OPTION_REG modifica lo siguiente:

T0CS: bit de seleccin de la fuente de reloj para el TMR0.

1 = transicin RA4/T0CKI.
0 = ciclo de reloj interno (CLKOUT).
T0SE: flanco de transicin del TMR0.
1 = incrementa con transicin de alto a bajo.
0 =incrementa con transicin de bajo a alto.
PSA: asignacin del preescalador.
1 = el preescalador es asignado a el WDT.
0 = el preescalador es asignado al modulo Timer0.
PS2:PS0: bits de seleccin para la frecuencia del preescalador.

EL CONTADOR/TEMPORIZADOR
TMR0
La siguiente tabla determina el divisor de frecuencia programado:
PS2, PS1 y PS0
000
001
010
011
100
101
110
111

TMR0
1:2
1:4
1:8
1:16
1:32
1:64
1:128
1:256

El tiempo de desbordamiento el TMR0 se calcula segn la

siguiente ecuacin:

COMO TRABAJO CON LA INTERRUPCION

POR DESBORDAMIENTO DEL TMR0?
El compilador C CCS tiene una directiva usada para el
manejo de interrupciones usando el desbordamiento
del TMR0:
#INT_TIMER0
Funciones definidas para el manejo del TMR0:
setup_timer_0(mod);
//configura el TMR0
Donde mod indica la funcin a realizar por el TMR0
set_timer0(valor);
aux=get_timer0(valor);

//escribe valor (8 bits) en el registro.

//lee valor (8 bits) actual del registro.

FUNCIONES DEFINIDAS
mod

OPTION_REG

RTCC_INTERNAL
RTCC_EXT_L_TO_H

0X00
0X20

RTCC_EXT_H_TO_L
RTCC_DIV_1
RTCC_DIV_2
RTCC_DIV_4
RTCC_DIV_8
RTCC_DIV_16
RTCC_DIV_32
RTCC_DIV_64
RTCC_DIV_128
RTCC_DIV_256

0X30
0X08
0X00
0X01
0X02
0X03
0X04
0X05
0X06
0X07

Los mod se pueden agrupar mediante el

smbolo |.

APLICACION 6

Desarrollar un sistema que permita generar

una seal cuadrada de 1 kHz utilizando la
interrupcin TMR0

EXPLICACION!!!
Para generar una seal de 1 kHz se necesita un
semiperiodo de 500 us. Segn la ecuacin para calculo
del TMR0, utilizando un cristal de 4 MHz y u
preescalador de 2, se tiene:

Esta relacin solo se cumple en ensamblador, pero en

lenguaje C, el compilador genera lneas de cdigo que
aumentan el tiempo de ejecucin. Por tanto el valor a
cargar es:

#INCLUDE <16F876.h>
#use delay(clock=4000000)
#fuses XT,NOWDT
#use standard_io(B)
#int_TIMER0

//directiva de int. desb. TMR0

void TIMER0_isr(void) {
output_toggle(PIN_B0);
set_timer0 (0x1B); }

//Se recarga el timer0

void main() {
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2);

//Configuracin timer0

set_timer0 (0x1B);
//Carga del timer0
enable_interrupts(INT_TIMER0);
//Habilita interrupcin timer0
enable_interrupts(global);
//Habilita interrupcin general
while (1);

//bucle infinito

SIMULACION

SIGAMOS CON
EL CONVERSOR
ANALOGO DIGITAL (A/D)

CARACTERISTICAS
Los microcontroladores PIC de gama media
posee un C A/D con las siguientes
caractersticas:
10 bits de resolucin.
8 Canales de entrada.
La resolucin es funcin de la tensin de referencia.

EJEMPLO
Vref+ = 5Vdc

Vref- = tierra
Y el numero de bits del convertidor es: N = 10
Resolucin= 5 / 1024
Resolucin = 4.8 mV / bit.
Ahora, si la lectura es 512 LSB, la tensin analgica leda es:

VIN = 512 * 4.8 mV

VIN = 2,4567 V

REGISTROS DE TRABAJO
El mdulo de A/D tiene cuatro registros. Estos
registros son:
ADRESH : Parte alta del resultado de la
conversin.
ADRESL: Parte baja del resultado de la
conversin.
ADCON0: Registro de Control 0 ;control del
funcionamiento del conversor.
ADCON1:
Registro
de
Control
1;
configuracin de los pines del puerto.

REGISTRO ADCON0
Controla la operacin del CA/D

ADCS1:ADCS0: En estos dos bits se hace la

seleccin de la frecuencia de reloj para el
Convertidor A/D.
00 = Fosc/2
01 = Fosc /8
10 = Fosc/32
11 = FRC (Procede del oscilador RC interno)

REGISTRO ADCON0
Controla la operacin del CA/D

CH2:CH0: Aqu se selecciona el canal analgico por donde

entrar la seal a digitalizar.
000 = Canal 0, (RA0/AN0)
001 = Canal 1, (RA1/AN1)
010 = Canal 2, (RA2/AN2)
011 = Canal 3, (RA3/AN3)
100 = Canal 4, (RA4/AN4)
101 = Canal 5, (RA5/AN5)
110 = Canal 6, (RA6/AN6)
111 = Canal 7, (RA7/AN7)

REGISTRO ADCON0
Controla la operacin del CA/D

GO/#DONE: bit de estado de la conversin A/D.

1 = La conversin A/D est en marcha (mientras est a 1 se est
realizando la conversin).
0 = La conversin ha finalizado. (el bit se pone a cero
automticamente por hardware cuando la conversin A/D finaliza)
el resultado de la conversin aparece en ADRESH:ADRESL.

ADON: bit de puesta en marcha

1 = El convertidor A/D est operativo.
0 = El convertidor A/D est apagado y no consume corriente.

REGISTRO ADECON1
Se trata de un registro de configuracin de los pines
del puerto, este registro se compone de 8 bits:

ADFM: Selecciona el formato del resultado de la

conversin A/D.
1 = Pone en el registro ARDESH los seis bits de mayor peso a 0.
0 = Pone los 6 bits de menor peso del registro ADRESL a 0.

REGISTRO ADECON1
PCFG3:PCFG0: bits de configuracin de los canales
de entrada del convertidor A/D. Se utilizan para
configurar las patillas como E/S digital o como
entrada analgica: A= Entrada Analgica; D = E/S Digital

REGISTROS ADRESH - ADRESL

El par de registros ADRESH:ADRESL se carga con el
resultado de 10 bits de la conversin A/D. Este par de
registros se extienden hasta 16 bits. El mdulo A/D
tiene la posibilidad de justificar el resultado de 10 bits
dentro de los 16 bits de la pareja de registros. La
seleccin del formato de justificacin a la izquierda o
derecha se realiza con el bit ADFM (ADCON1). Los bits
restantes (a los 10 de la conversin) se llenan con
ceros.
NOTA:
Estos dos registros cuando el convertidor A/D est en
OFF y no se utiliza, pueden utilizarse como dos
registros de 8 bits de propsito general.

COMO TRABAJO CON EL

CONVERSOR ANALOGO DIGITAL?
En el compilador C las funciones para manejar
el conversor A/D son las siguientes:
setup_adc(modo);
modo: para la configuracin del mdulo conversor
correspondientes a los bits 7:6 del registro ADCON0.
setup_adc(modo);

ADCON0(1Fh)

ADC_OFF

00000000 - 00h

ADC_CLOCK_INTERNAL

11000000 - C0h

ADC_CLOCK_DIV_2

00000000 - 00h

ADC_CLOCK_DIV_8

01000000 - 40h

ADC_CLOCK_DIV_32

10000000 - 80h

A/D

COMO TRABAJO CON EL

CONVERSOR ANALOGO DIGITAL?
setup_adc_ports(valor);
Valor: definicin de las entradas analgicas correspondientes a
los bits 3 0 del ADCON1.

setup_adc_channel(canal);
Canal: seleccin del canal analgico correspondiente a los bits
5:3 del registro ADCON0.

Posibles valores para SETUP_ADC_PORTS(VALOR);

ADEMAS
Valor = read_adc();
//Lectura del ADC.
Lectura del resultado donde valor es un nmero entero
de 16 bits segn la directiva #DEVICE ADC =
empleada. Dicha directiva trabaja segn la tabla:

APLICACION 7

Desarrollar un sistema que permita leer una

tensin analgica por el canal 0 (AN0),
proveniente de una fuente, realizando la
variacin por medio de un potencimetro.

#include <16F876.h>
#device adc=10
//directiva para manejo ADC 10 bits
#FUSES XT, NOWDT
#use delay(clock=4000000)

//reloj

#include <LCD.C>

//librera LCD

void main() {
int16 q;
float p;

//inicio de programa
//declaracion de variables.

setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);

//Canal 0 analgico
//Fuente de reloj RC

lcd_init();
for (;;) {
set_adc_channel(0);
delay_us(20);
q = read_adc();
p = 5.0 * q / 1024.0;

//ciclo infinito de ejecucin

//Habilitacin canal 0
//tiempo de estabilizacin
//Lectura canal 0
//Conversin a tensin

printf(lcd_putc, "\fADC = %4ld", q);

printf(lcd_putc, "\nVoltage = %01.2fV", p);
delay_ms(100);
}

SIMULACION

SIGAMOS CON
COMUNICACION SERIAL
USANDO EL MODULO
USART

COMUNICACION SERIAL
CARACTERISTICAS:

Transmisin de un bit a la vez.

Comunicacin mucho ms lenta.
Requiere de un nmero menor de lneas para
la transmisin.
Distancia de transferencia mayor.

COMUNICACION SERIAL
Es una interfaz que designa una norma para el
intercambio serie de datos binarios entre un equipo
terminal de datos (DTE) y un equipo de terminacin del
circuito de datos (DCE). Permite comunicacin con
otras computadoras y otros dispositivos como: mouse,
impresoras, microcontroladores.

COMUNICACION SERIAL
El RS-232 C es una norma para la conexin entre un DTE y un
DCE que define:

Las caractersticas elctricas.

Los niveles de tensin.
Las longitudes mximas a distintas velocidades.
Los nombres de las seales que intervienen en el
funcionamiento y la estructura del protocolo de comunicacin.
El tipo de conector a emplear.
Esta norma establece una sealizacin elctrica bipolar:
Recepcin:
Nivel lgico 0 : +15...+3Voltios.
Nivel lgico 1 : -15...-3Voltios.
Transmisin:
Nivel lgico 0 : +15+5 Voltios.
Nivel lgico 1 : -15-5 Voltios.

COMUNICACION SERIAL
Existen dos formas de comunicacin serial:
Sincrnica: adems de una lnea sobre la que
transfieren los datos, se necesita otra que contenga
los pulsos de reloj.
La duracin del bit est determinada por la duracin
del pulso de sincronismo.

COMUNICACION SERIAL
Existen dos formas de comunicacin serial:
Asincrnica: los pulsos de reloj no son necesarios y
se acude a otros mecanismos para realizar la
lectura/escritura de los datos.
la duracin de cada bit est determinada por la
velocidad con la cual se realiza la transferencia de
datos.

COMUNICACION SERIE SINCRONA:

USART
Los microcontroladores PIC16f8xx dispone de un
mdulo USART capaz de soportar la comunicacin
sncrona y asncrona.
En el modo asncrono, la transferencia de informacin
se realiza sobre dos lneas TX (transmisin) y RX
(recepcin), a ritmo de una frecuencia controlada
internamente por el USART.

COMUNICACION SERIE SINCRONA:

USART
Los bloques que configuran la arquitectura USART:
Circuito de muestreo: identifica el bit de informacin
recibido por medio de muestreo.
Generador de Baudios: frecuencia en Baudios (bits
por segundo) a la que se realiza la transferencia:
330, 600, 1200,2400,4800,9600,19200,38400,.

Registro SPBRG, TXSTA.

COMUNICACION SERIE SINCRONA:

USART
Ecuacin para el clculo del valor con
que se carga el registro generador de
frecuencia SPBRG:

X=(Fosc/(FrecBaudios*K))-1
K = 64, BRGH = 0, baja velocidad.
K = 16, BRGH = 1, alta velocidad.

REGISTROS QUE INTERVIENEN EN UNA

COMUNICACION ASINCRONA
TXSTA: transmisor asncrono. Registro que
interviene en la transferencia de informacin:

Bit [0] TX9D.- Este es el noveno bit de datos en el caso de una transmisin de 9 bits.
Bit [1] TRMT.-Cuando est en 1 indica que el registro de transmisin TXREG est vaco, esto
implica que puede escribirse un nuevo dato.
Bit [2] BRGH.- Este bit slo se utiliza en modo asncrono, y sirve para seleccionar uno de los dos
modos de velocidades.
Bit [3] No se utiliza, se lee como 0.
Bit [4] SYNC.- Este bit se pone a 1 para utilizar el modo sncrono o a 0 para el modo asncrono.
Bit [5] TXEN.- En modo asncrono este bit se pone a 1 para activar las transmisiones de datos.
Bit [6] TX8/9.- Este bit selecciona una transmisin de 8 bits si est a 1 o de 9 bits si est a 1.
Bit [7] CSRC.- En modo asncrono, este bit no se utiliza.

REGISTROS QUE INTERVIENEN EN

UNA COMUNICACION ASINCRONA
BRG: depende del valor X cargado en el registro de
generacin de la relacin de baudios SPBRG y del
estado del bit BRGH del registro TXSTA

REGISTROS QUE INTERVIENEN EN

UNA COMUNICACION ASINCRONA
RCSTA: receptor asncrono. Los datos se reciben en
serie bit a bit por la patita RC7 y se va introduciendo
secuencialmente en el registro de desplazamiento.

Bit [0] RX9D.- Este es el noveno bit de datos en el caso de una transmisin de 9 bits.
Bit [1] OERR.- Este bit se pone a 1 en caso de error de desbordamiento.
Bit [2] FERR.- Este bit se pone a 1 en caso de error de formato.
Bit [3]. Deteccin de direccin. Maestro y esclavos.
Bit [4] CREN.- En modo asncrono debe estar a 1 para autorizar la recepcin. En modo
asncrono autoriza que se contine la recepcin.
Bit [5] SREN.- En modo asncrono no se utiliza, en modo asncrono este bit debe estar a 1 para
activar la recepcin.
Bit [6] RX8/9.- Este bit debe estar a 1 para activar la transmisin de 9 bits.
Bit [7] SPEN.- Este bit debe estar a 1 para activar la USART.

COMO MANEJO EL MODULO

USART EN MODO ASINCRONO?
Configuracin genrica de la USART:

# USE rs232 (opciones) //Directiva para rs232

Se configuran varios parmetros de la USART:
velocidad de transmisin (EN BAUDIOS).
BAUD = X

bits de transmisin (8 o 9 bits).

BITS = X

pines utilizados (transmisin / recepcin).

XMIT = pin

COMO MANEJO EL MODULO

USART EN MODO ASINCRONO?
Una anotacin importante para el uso de la directiva es
que se debe definir primero la directiva: # use delay()
Ejemplo:
#use delay (clock = 4000000)
#use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7, bits=8)

FUNCIONES DEFINIDAS
Algunas funciones de la USART:
setup_uart(baud);
baud es una constante que define la velocidad.
set_uart_speed(baud);
baud es una constante que define la velocidad.
Ejemplo:
set_uart_speed(2400);
set_uart_speed(4800);
set_uart_speed(9600);
set_uart_speed(19200);

FUNCIONES DEFINIDAS
Para transmisin de datos:
putc(cdata);
putchar(cdata);
cdata es un carcter de 8 bits.
puts(string);
string es una cadena de caracteres constante o matriz
de caracteres terminada con un 0. (puts () manda los
caracteres de la cadena uno a uno por medio de la
funcin putc ()).

OTRAS FUNCIONES
printf (fname, cstring, values);
cstring: es una cadena de caracteres o matriz de
caracteres terminados con un 0.
fname: las funciones utilizadas para escribir la cadena
indicada (por defecto se utiliza la funcin putc).
values: valores a incluir en la cadena separados por
comas. %nt, donde n es opcional.
1 9: para especificar cuantos caracteres se quiere.
01 09: para indicar la cantidad de ceros a la izquierda.
1.1 1.9 para coma flotante.

carcter

Cadena o carcter

Entero sin signo

Entero con signo

Lu

Entero largo sin signo

Ld

Entero largo con signo

Entero hexadecimal (minsculas)

Entero hexadecimal (maysculas)

Lx

Entero largo hexadecimal (minsculas)

LX

Entero largo hexadecimal (maysculas)

Flotante con truncado

Flotante con redondeo

Flotante en formato exponencial

Entero sin signo con decimales insertados

FUNCIONES DEFINIDAS
Funciones para recepcin de datos:
value = getc ();
value = getch ();
value = getchar ();
value es un carcter de 8 bits.
valor = kbhit ();
valor es 0 (FALSE) getc() debe esperar a que llegue
un carcter.
valor es 1 (TRUE) ya hay un carcter que puede ser
ledo por la funcin getc().

APLICACION 8

Desarrollar un sistema que permita enviar los datos del

0 al 10, en modo asncrono, entre dos PIC, visualizar
con LCD los datos enviados y los recibidos. La
recepcin de datos se realizara por interrupcin de
USART.

DESARROLLO DEL
SISTEMA DE
TRANSMISION PARA EL
MICROCONTROLADOR A

#include <16F877.h>
#FUSES XT,NOWDT
#use delay(clock=4000000)

//reloj

#use rs232(baud=9600, xmit=pin_c6, rcv=pin_c7)

//Configura velocidad en baudios 9600, pin C6 para TX,
//pin C7 para RX
#include <LCD.C> //directiva LCD

void main() {
int valor;
lcd_init();

//funcin principal
//declaracin de variable.
//inicializa LCD

while(1){
//ciclo de ejecucin infinito
for (valor=0;valor<=10;valor++) {
//envo de datos
PUTC(valor);
//enva datos al hiper terminal
printf(lcd_putc,"\fenviando=%1D",valor); //enva dato a LCD
delay_ms(500);
}
}
}

DESARROLLO DEL
SISTEMA DE RECEPCION
PARA EL
MICROCONTROLADOR B

#include <16F876.h>
#FUSES XT,NOWDT
#use delay(clock=4000000)

//reloj

#use rs232(baud=9600, xmit=pin_c6, rcv=pin_c7, bits=8)

//Configura velocidad en baudios 9600, pin C6 para TX,
//pin C7 para RX, 8 bits de datos.
#include <LCD.C>

//directiva para manejo de LCD

//para el manejo de interrupcin cuando se recibe un dato

se usa la //directiva #INT_RDA
#INT_RDA
RDA_isr()
{
valor=GETC();
}

//Directiva de interrupcin por

//recepcin de datos

//lee el dato recibido y guarda en valor

void main() {
//funcin principal
lcd_init();
//inicializa LCD
enable_interrupts(INT_RDA); //int. Por recepcin activa
enable_interrupts(GLOBAL); //permiso global de int.
for (;;) {
//ciclo infinito de ejecucin
lcd_gotoxy(1,1);
printf(lcd_putc,"recibiendo=%1D",valor);
//escribe en LCD en la posicin 1,1.

}
}

SIMULACION

PARA FINALIZAR
EL MODULO I2C (Interfaz
Inter Circuitos) Y LAS
MEMORIAS EEPROM

EL BUS I2C

CARACTERISTICAS:
Se basa en la comunicacin a travs de dos hilos.

Dos lneas de colector abierto reloj (SCL) y datos (SDA).

Se debe usar resistencias de pullups.
Cada dispositivo conectado al bus tiene una direccin.
Se configura como mono maestro o multi maestro.
El maestro se encarga de: inicio y finalizacin de transferencia,
con quien y el sentido de la misma.
El maestro inicia transferencia enviando la direccin del
dispositivo con que se quiere conectar, ya sea para lectura o
escritura.
El numero de dispositivos conectados y la longitud de conexin
se limitan por la capacidad de direccionamiento (de 7 a 10 bits) y
por la mxima carga del bus (400pF).
La velocidad mxima estndar es 100 Kbps y en adelante para
versiones mejoradas.

CONDICIONES DELBUS

FORMATOS DE TRANSFERENCIA DE
INFORMACION

ESCRITURA EN EL ESCLAVO: Maestro como transmisor y esclavo

como receptor.

LECTURA DEL ESCLAVO: El maestro lee informacion proveniente del

esclavo inmediatamente despus de transmitir el byte de control y se
configura como receptor.

FORMATOS DE TRANSFERENCIA
DE INFORMACION
FORMATO COMBINADO: este formato implica el
cambio de sentido de la informacion, as que el
dispositivo que en principio se comporta como
receptor, luego lo har como transmisor.

CARACTERISTICAS ELECTRICAS

Permite la interconexin de diversas tecnologas (CMOS,

NMOS, TTL,).
Dispositivos con niveles de entrada fijos (5 V):
VIL = 1.5 v (estado bajo 0).
VIL = 3 v (estado alto 1).
Terminales conectados al bus I2C, no debern sumir ni drenar
corrientes superiores a 10 uA, ni capacidad mayor a 10 pF.

LA MEMORIA
EEPROM

LA MEMORIA 24LC256
Fabricada por microchip.
Capacidad de almacenamiento de 256 Kbits (32
Kbyts).
Compone de 512 paginas de 64 bytes cada una.
Tiempo de escritura 5 ms.
Ciclos de escritura/lectura 1000.000.
Velocidad mxima de operacin 400 KHz.
Consumo durante la escritura 3 mA a 5.5 V.
Consumo durante la lectura 400 uA a 5.5 V.
Capacidad de retencin mayor a 200 aos.

COMO MANEJO EL BUS I2C?

Configuracin genrica:

#USE I2C(opciones)
MULTI_MASTER

Establece modo multi maestro

MASTER

Establece modo maestro.

SLAVE

Establece modo esclavo.

SCL = pin

Especifica el pin SCL.

SDA = pin

Especifica el pin SDA.

ADDRESS = pin

Especifica la direccin en modo esclavo.

FAST

Utiliza velocidad alta.

SLOW

Utiliza velocidad baja.

RESTART_WDT
FORCE_HW
NOFLOAT_HIGH
SMBUS
STREAM = id

Borra el WDT mientras espera una lectura.

Utiliza las funciones I2C hardware.
No permite seales flotantes.
Utiliza el bus en formato SMBUS.
Asocia un identificador stream.

FUNCIONES DEFINIDAS PARA EL

MANEJO DE LA MEMORIA EEPROM
Funcin de escritura:

write_ext_eeprom(direccion, valor);
Funcin de lectura:

valor = read_ext_eeprom(direccion);

APLICACION 9

Desarrollar un sistema que permita guardar y

leer 50 datos en una memoria EEPROM I2C.
Mostrar los valores escritos y ledos en un
display LCD.

#include <16f877.h>
//usamos el pic 16f877
#fuses xt, nowdt, nolvp, noprotect
#use delay(clock=4000000) //reloj
#include <LCD.C>
//Librera LCD
#include <J24lc256.H>
//librera EEPROM I2C
//se define I2C con modo maestro, pines SDA y SCL
#use i2c(MASTER,SDA=PIN_C4,SCL=PIN_C3)
INT cnt=0,JASO=0;

//variables globales

void main()
//funcin principal
{
lcd_init();
//Inicia LCD
init_ext_eeprom(); //Inicia memoria
while(true)
{

// bucle infinito

// escritura de la memoria con el valor de la posi +2

for(cnt=0;cnt<=50;cnt++)
{
write_ext_eeprom(cnt,(cnt+2)); // funcin de escritura
printf(lcd_putc,"\fESCRI.. POSI %u",cnt);
delay_ms(500);
}

//lectura de las 50 posi de la memoria

for(cnt=0;cnt<=50;cnt++)
{
jaso=read_ext_eeprom(cnt); // funcin de lectura
printf(lcd_putc,"\fLEER.. POSI %u",jaso);
delay_ms(500);}
}
}

SIMULACION

El mini curso que acabamos de

presenciar permite explorar un poco mas
acerca de cmo podemos programar los
microcontroladores
PIC
usando
herramientas de alto nivel como lo es el
compilador C CCS y el simulador
proteus, que permiten obtener el mximo
rendimiento en nuestras habilidades
como programador y la optimizacin y
funcionalidad del microcontrolador en
sus diferentes aplicaciones.

Recordemos que este mini curso e una

pequea introduccin a lo que USTED
como programador se puede enfrentar
de ahora en adelante

ANIMO!!!
A PROGRAMAR
SE DIJO!!!...