Manual Microcontroladores

Universidad Autnoma de San Luis Potos
Facultad de Ciencias
Manual de Prcticas de Laboratorio de la

asignatura Microcontroladores del PE Ingeniero
Electrnico
Con los DsPICs de la serie 30F

Usando el lenguaje C
Dr. J. Jess Acosta Elas

Manual de Prcticas del Laboratorio de Microcontroladores
ndice
Captulo Pgina
Introduccin 3
Practica 1, empezando 5
Practica 2, los puertos de entrada/salida 12
Prctica 3, el problema del Read Modify Write 15
Prctica 4, el temporizador (Timer) 18
Prctica 5, las Interrupciones 21
Prctica 6, el UART 24
Prctica 7, construir un voltmetro digital usando el ADC 29
Prctica 8, haciendo mltiples muestras 37
Prctica 9, haciendo mltiples muestras con el ADC de forma totalmente 45
automtica
Prctica 10, el mdulo PWM 52
J. Jess Acosta Elas 2

Introduccin
Motivacin
Los libros disponibles para ensear microcontroladores y en general la mayora de los cursos a
nivel licenciatura estn basados en microcontroladores de gama baja, que generalmente tienen
baja potencia de clculo, poca memoria, etc. y que por regla general se programan en
ensamblador. Estos cursos cumplen con su objetivo; la enseanza de la teora y la prctica de los
microcontroladores. Sin embargo con estos conocimientos y estos recursos solo se pueden
realizar proyectos pequeos. Por ejemplo, en lenguaje ensamblador calcular la media en punto
flotante de n muestras del convertidor analgico digital y guardar los resultados en un arreglo es
muy complicado, pensar en aplicar filtros a la seal es casi imposible.
La motivacin de escribir este manual de prcticas de laboratorio es proporcionar al estudiante un

material sencillo, con prcticas clsicas pero con microcontroladores de alto desempeo y que
adems se sugieren pequeos proyectos que es donde realmente el estudiante va adquirir
habilidades y competencias en la electrnica aplicada con microcontroladores.
El material contenido en este documento es el resultado de la experiencia en desarrollo de

proyectos tecnolgicos y de investigacin, as como de la experiencia docente obtenida
impartiendo la materia de microcontroladores en el PE Ingeniero Electrnico en la Facultad de
Ciencias de la UASLP:
Antecedentes sugeridos
Este manual de prcticas est planeado para los cursos de microcontroladores de la carrera de
Ingeniero Electrnico. En este manual se asume que el estudiante conoce los fundamentos
bsicos de electricidad y electrnica tanto analgica como digita, y que tambin saben programar
bien en lenguajes estructurados. Se recomienda conocer el lenguaje c. Sin embargo si conoce
bien algn otro lenguaje estructurado como pascal, java, etc. puede abordar con xito esta
asignatura.
Este manual no proporciona informacin terica de electrnica, de programacin ni de la teora

de los microcontroladores. La informacin terica y tcnica de los microcontroladores se
encuentra disponible en los apuntes del curso y en las hojas de datos de los fabricantes.
Breve descripcin de un microcontrolador

Los microcontroladores son dispositivos que encapsulan en un solo chip una computadora
completa. Entendindose como computadora un cpu y perifricos de entrada salida (e/s). Por
ejemplo una PC tiene cpu y como perifricos monitor, teclado, ratn, disco duro, etc. El
microcontrolador tiene el cpu y como perifricos tiene puertos de e/s, temporizadores (Timers),
uart, pwm, convertidor analgico digital, etc.
El cpu se comunica con los perifricos a travs de memoria compartida. Por ejemplo si el cpu
necesita arrancar un perifrico cualquiera, la orden la da el cpu modificando un registro de ese
perifrico. Por lo tanto el cpu como el perifrico comparten el acceso a ese registro.

Estas prcticas se basan en la familia 30F, que son un conjunto de microcontroladores de alto
desempeo diseados pensando en el lenguaje C y que adems disponen de procesamiento digital
de seales.
Una caracterstica muy importante y que no esta disponible en otros fabricantes, es que son chips
de alto desempeo que poseen varios encapsulados tales como TQFP, DIP, etc. y que de cara a la
docencia, el encapsulado DIP es muy importante porque fcilmente se monta en protoboards.
Nota: Todo el documento est realizado con software propietario adquirido legalmente

Practica 1, empezando.
El objetivo de esta prctica es que el estudiante se familiarice con el microcontrolador y las
herramientas necesarias para su programacin, as como con su configuracin.
Paso 1.
Armar el sistema mnimo.
Material
Cantidad Descripcin
1 dsPIC30F4013 o similar
1 Resistencia de 10k
1 Resistencia de un k
2 Capacitor 33 pf
1 Cristal 4 mhz
1 Diodo Emisor de luz (Led)
1 Tablilla para prototipo (Protoboard)
Armado del sistema (ver la figura 1.1)

La resistencia de 10k se conecta a la patita uno(MCLR) y a +V
El cristal de 4 Mhz se conecta a la patita OSC1 y a la patita OSC2
Uno de los capacitor de 33pf se conecta a la patita OSC1 y a tierra
El otro capacitor de 33pf se conecta a la patita OSC2 y a tierra
Se conectan las alimentaciones de voltaje positivo y negativo
El led se conecta a la patita 19 (RD3) a travs de la resistencia de 1 k
Todo proyecto con microcontroladores se divide en dos partes: El diseo y construccin del
hardware y el diseo y construccin del software.
Ya que se tiene armado el hardware sistema, es momento de escribir el programa. Es importante

recalcar que este manual de prcticas se basa en el lenguaje c, por lo tanto usaremos el conjunto
de herramientas que provee Microchip para el desarrollo de proyectos usando el lenguaje c y que
se conocen como C30. Este toolsuite se vende, pero Microchip proporciona una versin
gratuita para estudiantes, que es que la vamos a usar en este manual.

+v
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
dsPIC30F4013
17
10
11
12
13
14
15
16
18
19
20
2
6
7
1
4
5
8
9 +v
10K
1k
+v
GND
Fig. 1.1
Creacin del programa

Antes de crear nuestro primer proyecto, es necesario instalar el c30 que se puede bajar de
la pgina Web de microchip.
Creamos un proyecto con el programa MPLAB de Microchip (Ver capitulo 3 de los

apuntes del curso), pero en vez usar el Microchip ASM Toolsuite, usaremos el
Microchip C30 Toolsuite. A este proyecto le ponemos por nombre prj4013
Si no tenemos abierta la ventana del proyecto, la abrimos desde el menu windows del
mplab.
Ponemos el apuntador del ratn sobre la carpeta que se llama linker scripts y con el
botn derecho elegimos Add files y le agregamos el script p30f4013.gld que
usualmente est en la ruta C:\archivos de programa\microchip\MPLAB C30\support\ y
buscamos el archivo p30f4013.gld
Creamos un nuevo archivo con el nombre p01.c, con el siguiente contenido:
/*p01.c
*/
#include <p30f4013.h>

//************* BITS de configuracin ********************

_FOSC(CSW_FSCM_OFF & XT_PLL16); //XT con 16xPLL
_FWDT(WDT_OFF); //Deshabilita el Watch-Dog
_FBORPOR(PBOR_ON & BORV_20 & PWRT_16 & MCLR_DIS); //Reset si voltaje <2.0 volts,
// espera 16ms al energizarse y reset
deshabilitado
_FGS(CODE_PROT_OFF); //Proteccin de cdigo deshabilitada
//*************************************************
int main(void); //Prototipo funcin main
//************** Programa principal **********************

int main(void){
TRISD=0x0000;
LATDbits.LATD3=1;
}
//********************************************************
Despus que se tenga escrito el archivo, en la ventana del proyecto se sita el apuntador
del ratn sobre la carpeta source files y se le agrega este archivo.
El siguiente paso es compilar el programa. Para ello situamos el apuntador del ratn sobre
el icono Build All y presionamos el botn izquierdo. Si no tenemos errores, vemos en la
ventana de salida el mensaje BUILD SUCCEEDED: seguido de la fecha. Entonces ya
tenemos la versin binaria lista para cargarse en el microcontrolador.
Carga del programa en el microcontrolador
Para cargar o grabar el programa en el microcontrolador se usan unos dispositivos que se conocen
como Programadores. Existen diferentes clases y marcas de programadores. En los apuntes se
describe la construccin de un programador y su forma de usarse.
Este manual lo escribo con el objetivo de que sirva de gua en las practicas de microcontroladores
en los laboratorios de la Facultad. Por lo tanto usaremos un programador/depurador que se
encuentra disponible en el laboratorio de Automatizacin, el ICD2(In circuit Debuguer). El ICD2
es un dispositivo que permite programar los microcontroladores de Microchip estando montados
en el circuito, tambin permite la depuracin de los programas. Es una importante ventaja no
tener que extrae el microcontrolador del circuito(Protoboard o del circuito impreso), debido a que
el estudiante a veces se confunde y pone al microcontrolador al revs o desplazado a la izquierda
o a la derecha, lo que puede ocasionar que se dae.
Para usar el ICD2 se debe conectar al microcontrolador y al puerto usb de la computadora. Para
conectarlo al microcontrolador se hace uso de un conector especial que en seguida se describe.
El ICD2 tiene una entrada (zcalo) para un conector semejante al del telfono, pero con 6
conexiones. El telfono posee solo cuatro conexiones. De las seis conexiones que tiene el ICD2
solo se usan 5:
+V

Tierra
Reset
PGC
PGD
Estas conexiones se conectan al circuito de acuerdo a la figura 1.2. Es importante mencionar que
las patitas PGC y PGD pueden variar en diferentes microcontroladores. Por ejemplo en el 3011
PGC est en la patita 26 y el PGD en la patita 25.
Figura 1.2: En este diagrama se puede observar la forma de conectar el ICD2 al dsPIC30F4013
PGC y PGD comparten sus patitas con otros mdulos del microcontrolador. Por ejemplo en el
4013 PGC comparte la patita 8 con el EMUC, AN6, OCFA y el RB6 (Ver la hoja de datos del
4013). Cuando EL ICD2 est conectado al circuito, solo PGC y PGD estn en uso y no estn
disponibles los otros mdulos. Cuando se desconecta vuelven a estar disponibles las e/s en esas
patitas de los otros mdulos.
En este documento no describir la instalacin del ICD2, asumimos que ya est instalado y por lo
tanto solo describir la forma de usarse.

Carga del programa usando el ICD2
En el men Progammer del mplab se da click en la opcin Select programmer(Ver figura

1.3). El mplab nos presenta una lista de programadores, de esta lista elegimos MPLAB ICD 2.
En seguida aparece una barra de men del ICD2(Ver figura 1.4). Esta barra contiene varios
iconos, todos estn deshabilitados, excepto el de la derecha (figura 1.4)
Figura 1.3: Esta imagen muestra como seleccionar al ICD2 en el mplab
Figura 1.4: Barra de herramientas del ICD2 en la que se puede ver el nombre del icono situado a
la derecha y el situado a la izquierda.
Para activar la conexin del ICD2 al circuito, movemos el apuntador del ratn sobre el icono
Reset and Connect to ICD y presionamos el botn izquierdo, y si todo est correcto (armado y
conexiones del ICD2), se activan el resto de iconos. Esto significa que ya podemos grabar el
programa en el 4013. Para grabar el programa, llevamos el apuntador del ratn al icono Program
target device y presionamos el botn izquierdo. Cuando termina el proceso de grabado, el
microcontrolador es reiniciado (reset). Y el programa empieza a ejecutarse.
Explicacin del programa
Figura 1.5. Este es el cdigo de nuestro primer programa. Lo mostramos as para verlo con
nmeros de lnea
La lnea 3, incluye el archivo de cabecera para el 4013, si fuera otro microcontrolador, por
ejemplo el 3011, el archivo sera p30f3011.h.
En la lnea 5 comienza la configuracin del microcontrolador

La funcin _FOSC() configura el oscilador:
o CSW_FSCM_OFF (Clock Switch Fail Safe Clock Monitor)= Deshabilita la
opcin de que cuando falle el oscilador externo, cambie al interno.
o XT_PLL16 = El microcontrolador va a esperar 16 milisegundos despus de que
se ha energizado, para que el voltaje se haya estabilizado.
La funcin _FWDT() es para habilitar o deshabilitar el watch dog
La funcin _FBORPOR() es para establecer algunas opciones de requerimientos
elctricos
o PBOR ON u OFF = Activa o desactiva la opcin de Power-on reset y Brown-
out reset. Power-on reset genera un reset cuando el circuito se energiza. Para
ms informacin ver la seccin Reset de la hoja de datos de la familia 30f
o BORV: Establece el voltaje al que se genera un brown-out reset cuando el
voltaje de alimentacin cae por debajo de l.
o PWRT: Establece el tiempo que el microcontrolador va a esperar para empezar a
funcionar despus de que se ha energizado. En este caso son16 milisegundos. Esto
es para que comience a funcionar cuando el voltaje se haya estabilizado.
o MCLR_DIS: Deshabilita el Master Clear Reset.

La funcin FGS() Habilita deshabilita la proteccin de cdigo. Si se habilita no se puede

leer el programa contenido en el microcontrolador, pero tampoco se puede reprogramar.
En la lnea 16 comienza el programa principal.

En la lnea 17 se define al puerto D con todas sus patitas como salida (Ver el captulo 4 de los
apuntes del curso)
En la lnea 18 se pone un uno en la patita RD3. Lo que origina que por esa patita salga un uno
lgico.
En al lnea 19 finaliza el cuerpo del programa principal.
Es importante mencionar que cuando se llega al final del programa, ste se reinicia, generndose
un reset. Para verificar esto, se conecta a la patita RD3 un osciloscopio. De esta manera podemos
observar como el diodo emisor de luz (LED) prende y apaga a pesar de que el programa lo
prende y no lo apaga
Con esto termina la prctica 1.

Practica 2, los puertos de entrada/salida

El objetivo de esta prctica es que el estudiante experimente con los puertos de E/S. En esta
prctica se prender y apagar un led usando un push-button
Paso 1.
Armar el sistema mnimo.
Material
Cantidad Descripcin
1 dsPIC30F4013 o similar
1 Resistencia de 10k
2 Resistencia de un k
2 Capacitor 33 pf
1 Cristal 4 mhz
1 Diodo Emisor de luz (Led)
1 Tablilla para prototipo (Protoboard)
1 Push-button
Armado del sistema (ver la figura 1.1)

La resistencia de 10k se conecta a la patita uno(MCLR) y a +V
El cristal de 4 Mhz se conecta a la patita OSC1 y a la patita OSC2
Uno de los capacitor de 33pf se conecta a la patita OSC1 y a tierra
El otro capacitor de 33pf se conecta a la patita OSC2 y a tierra
Se conectan las alimentaciones de voltaje positivo y negativo
El led se conecta a la patita 35 (RB12) a travs de la resistencia de 1 k
El push-button se conecta a la patita 36 (RB11) y a +V. Y la otra terminal se conecta a
tierra (Ver figura 2.1)
Todos los puertos tienen tres registros asociados, uno de configuracin, el TRISx, por
ejemplo el del puerto B es TRISB. Uno de entrada PORTx y uno de salida el LATx. Pero el
puerto B, adems tiene otro registro de configuracin, el ADPCFG. Este registro se usa para
configurar si la entrada es analgica digital. Esto es debido a que el puerto B comparte sus
patitas con el Convertido Analgico Digital. Aprovechamos esta prctica para aprender esta
caracterstica del puerto B.
Si cualquier bit del registro ADPCFG es puesto a 1, la patita asociada a ese bit es una entrada
digital. Y Si cualquier bit del registro ADPCFG es puesto a 0, la patita asociada a ese bit es
una entrada analgica. Cada bit del ADPCFG despus de un reset contiene un cero.
Si usamos una varias patitas del puerto B para entrada digital y no ponemos a 1 los bits
adecuados en el registro ADPCFG, el programa tendr respuestas impredecibles.

+
1K
RB11
RB12
30F4013
1k
Figura 2.1
El algoritmo: Si presionamos el push-button, se prende el led, si lo liberamos, se apaga el led.
Es importante observar que si el push-button no est presionado, RB11 recibe +V, esto significa
que recibe un uno lgico, si lo presionamos, entonces +V se va a tierra a travs de la resistencia y
RB11 recibe un cero lgico.
El programa:
/*
p02.c
*/
//************* BITS de configuracion ********************

_FOSC(CSW_FSCM_OFF & XT_PLL16); //XT con 16xPLL
_FWDT(WDT_OFF); //Deshabilita el Watch-Dog
_FBORPOR(PBOR_ON & BORV_20 & PWRT_16 & MCLR_DIS);
_FGS(CODE_PROT_OFF); //Disable Code Protection
//*************************************************
int main(void); //Prototipo funcion main

int main(void){
TRISD=0x0000;
LATDbits.LATD3=1;
TRISB = 0xEFFF; //1110 1111 1111 1111
ADPCFG = 0xFFFF; //Todas entradas digitales
while(1){
if(PORTBbits.RB11 == 0)
LATBbits.LATB12 = 1;
else
}
}
//********************************************************

Esta prctica usa un push-button, y debido a que los contactos de este tipo de dispositivos tardan
un cierto tiempo en estabilizarse cuando se unen (Ver apuntes Cap5). Para reducir este problema
hay varias opciones de hardware y de software que en su momento se estudiarn.
PROYECTOS:
Despus de haber realizado esta prctica, el estudiante est preparado para realizar algunos
proyectos con el objetivo de reforzar los conocimientos adquiridos. Se recomiendan los
siguientes:
Proyecto 1.1: Mostrar un nmero en un display de 7 segmentos. Este nmero es el ndice

en la lista de asistencia. Por ejemplo si alguien es el numero 5 en la lista, pues su proyecto
es mostrar dicho nmero. Si es de ms de un dgito, por ejemplo 13, se suman (4) y el
obtenido es el que se mostrar
Proyecto 1.2: Con un dip-switch dar un nmero binario de 4 bits y mostrarlo en decimal
en un display de 7 segmentos.
Proyecto 1.3: Decodificar un teclado matricial de 4*4 y mostrar el nmero en un display

de 7 segmentos.
Proyecto 1.4: Usando el proyecto 1.3, construir un teclado que permita al usuario escribir
una clave, si es correcta encienda un led mbar y si es errnea, encienda un led rojo.

Prctica 3, el problema del Read Modify Write

El objetivo de esta prctica es observar el problema del Read Modify Write
Se construye un circuito como el de la prctica anterior, pero ahora se conectan 8 leds con su
respectivas resistencia de 1k al puerto B, empezando en RB0, RB1...RB7, las resistencias van
conectadas en serie (Para limitar la corriente). El push.button se conecta al RB11 (igual que en la
prctica pasada).
Algoritmo: Si se presiona el push-button, se prenden los leds, si se libera, se apagan.
Si usamos el siguiente programa, los resultados son imprevisibles debido al problema del read
modify write
+
1K
RB11
30F4013
RB0
RB1
RB2 1k
RB3 1k
RB4 1k
RB5 1k
RB9 1k
RB10 1k
1k
1k
Figura 3.1
Programa:
/*
p04.c
*/

_FOSC(CSW_FSCM_OFF & XT_PLL16);
_FWDT(WDT_OFF);
_FGS(CODE_PROT_OFF);
//********************************************************

int main(void){
TRISD=0x0000;
LATDbits.LATD3=1;
TRISB = 0b0000100000000000; //Todas salidas, solo RB11 entrada

while(1){

if(PORTBbits.RB11 == 0){
PORTBbits.RB12 = 1;
PORTBbits.RB0 = 1;
PORTBbits.RB1 = 1;
PORTBbits.RB2 = 1;
PORTBbits.RB3 = 1;
PORTBbits.RB4 = 1;
PORTBbits.RB5 = 1;
PORTBbits.RB9 = 1;
PORTBbits.RB10 = 1;
}
else{
PORTBbits.RB12 = 0;
PORTBbits.RB0 = 0;
PORTBbits.RB1 = 0;
PORTBbits.RB2 = 0;
PORTBbits.RB3 = 0;
PORTBbits.RB4 = 0;
PORTBbits.RB5 = 0;
PORTBbits.RB9 = 0;
PORTBbits.RB10 = 0;
}
}
}
//********************************************************
Es importante observar en un osciloscopio cada uno de las patitas de salida que se activan en el
programa y discutir los resultados en clase.
El siguiente programa es la forma correcta de resolver el algoritmo propuesto en la prctica.

/*
p03.c
*/
_FWDT(WDT_OFF);
//*******************************************************

int main(void){
TRISD=0x0000;
LATDbits.LATD3=1;
TRISB = 0b0000100000000000; //Todas salidas, solo RB11 entrada

while(1){
if(PORTBbits.RB11 == 0){
LATBbits.LATB0 = 1;
LATBbits.LATB1 = 1;
LATBbits.LATB2 = 1;
LATBbits.LATB3 = 1;
LATBbits.LATB4 = 1;
LATBbits.LATB5 = 1;
LATBbits.LATB9 = 1;
}
else{
LATBbits.LATB0 = 0;

LATBbits.LATB1 = 0;
LATBbits.LATB2 = 0;
LATBbits.LATB3 = 0;
LATBbits.LATB4 = 0;
LATBbits.LATB5 = 0;
LATBbits.LATB9 = 0;
}
}
}
//********************************************************
Igual que con el programa anterior, observar la forma de onda en osciloscopio en cada uno de las
patitas de salida activadas por el programa y discutir los resultados y compararlos con el
programa anterior.
Fin de prctica

Prctica 4, el temporizador (Timer)

Esta prctica tiene como objetivo, entrenarse en el uso del temporizador (Timer), ver el captulo 5
de los apuntes.
Primero revisamos unos sencillos conceptos:
Fosc = Frecuencia de oscilacin. Por ejemplo si usamos un cristal de 4 mhz y un

multiplicador de 16, obtenemos Fosc = 4*16 = 64 Mhz.
Fcy = Frecuencia de instruccin. El dspic realiza una instruccin cada 4 Fosc. Por lo tanto
el Fcy=Fosc/4 = 16 Mhz. En este ejemplo. Generalmente a lo largo de todas las
prcticas estos son los valores que usaremos.
Tfosc = Periodo de oscilacin. Tfosc = 1/Fosc = 1/64000,000 = 0.000,000,015,625 seg =

15.625 ns
Tcy = 1/Fcy = 1/16,000,000 = 0.000,000,0625 seg = 62.5 ns
Esto significa que el dspic con un cristal de 4 mhz y un multiplicador de frecuencia de 16, es
capaz de realizar 16 millones de instrucciones por segundo. O dicho de otra manera, es capaz de
realizar una instruccin cada 62.5 ns.
El dspic tiene tres timers: Timer 1, Timer 2 y Timer 3. En esta prctica usaremos el timer 1.
El timer 1, es de 16 bits, eso significa que puede contar desde 0 a (2^16)-1, Cada cuenta tarda un
tcy, por lo tanto, contar de 0 a (2^16)-1, tarda 0.001,023 segundos.
Una de las funciones del timer es que el microcontrolador espere un cierto tiempo (retardo o
tiempo muerto) antes de realizar alguna accin. Para poder crear retardos ms largos se usa un
prescaler, que en realidad es un divisor de frecuencia.
Ahora como ejemplo calcularemos un retardo de 120 ms.
Fcy = 16,000,000
Con un prescaler de 256
16,000,000/256 = 62,500
Esto significa que el timer hace 62,500 en un segundo, usando el prescaler de 256
1000 ms = 62500
------ --------
120 x
x = (62500*120)/1000 = 7500 = 0x1D4C
Esto significa que si el timer realiza 7500 cuentas en 120 ms.

Algoritmo: Generar una onda cuadrada que dure 120 ms entregando seal (uno lgico) y 120 ms
sin entragar seal (cero lgico).
Programa:
/*
p05.c
*/

_FWDT(WDT_OFF);
//********************************************************
void retardo120ms( void ); //Prototipo funcin

int main(void); //Prototipo funcin main

int main(void){
TRISD=0x0000;
LATDbits.LATD3=1;
TRISB = 0; //Todas salidas
while(1){
LATB=0x0001;
retardo120ms();
LATB=0x0000;
retardo120ms();
}
}
//********************************************************
void retardo120ms( void ){

/* Asegurarse que el Timer 1 est en estado de reset */
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
/* set Timer 1 period register */
PR1 = 0x1D4C;
IFS0bits.T1IF = 0; //Clear the timer1 interrupt status flag
IEC0bits.T1IE = 0; //Disable Timer1 interrupts
T1CON = 0x8030; //Configura T1CON=1000000000110000
while(IFS0bits.T1IF==0);
}
Es importante recalcar que el timer es un mdulo que funciona en paralelo al cpu.
En este ejemplo el cpu se queda esperando a que la bandera T1IF cambie su estado de cero a uno
para salir del ciclo while. En otras palabras la condicin del ciclo while(IFS0bits.T1IF==0);
va a ser verdadera mientras no termine de contar el timer, en el momento que el timer llega a
7500, la bandera cambia a uno, y la condicin del ciclo se vuelve falsa y se sale del ciclo y se
regresa de la funcin al programa principal.

Proyectos:
Proyecto 1: Construir un generador de onda cuadrada. Que tenga dos botones, con el botn 1,
entregue una onda cuadrada con un periodo de 40 ms y con el botn dos una frecuencia de 20 ms
Proyecto 2: Construir un reloj digital que muestre segundos (del 0 al 9) y dcimas de segundo,
tambin del cero al nueve. Es de esta manera para solo usar dos displays de 7 segmentos.
Proyecto 3: Modificar la prctica 3, para que se eviten los rebotes del push-button usando un
retardo de 120 ms.
Proyecto 4: Control de un motor de pasos
Proyecto 5: Uso de un LCD
Es muy recomendable que se lleven a cabo los proyectos 3, 4 y 5.

Prctica 5, las Interrupciones

El objetivo de esta prctica es que el estudiante aprenda el uso de las interrupciones. El cpu, en
todo momento est ejecutando un programa, y las interrupciones son un mecanismo para que se
detenga y atienda algn dispositivo. Por ejemplo en la PC existen interrupciones que se llaman
IRQ, estas interrupciones atienden a algunos dispositivos como el teclado con la IRQ=1, el disco
duros con IRQ=5, etc. Para ms informacin sobre interrupciones del dsPIC ver capitulo 6 de los
apuntes del curso.
+
+ 1K
+v
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
Push1
dsPIC30F4013
17
10
11
12
13
14
15
16
18
19
20
2
6
7
1
3
4
5
8
9
1K
10K 1k Led 2
+ 1k
+v
Led 1
GND
+
Push2
Figura 5.1
Lista de material adicional al sistema mnimo:
2 Push-buttons
3 Resistencias de 1k
1 Led
Conexiones
1. Se conecta la patita 23 del 4013 (Interrupcin 0) al push-button 1 y a +V. La conexin

restante del push-button se conecta a tierra.

2. Se conecta la patita 17 del 4013 (Interrupcin 1) al push-button 2 y a +V. La conexin
restante del push-button se conecta a tierra.
3. Se conecta la patita 18 del 4013 al led1 a travs de una resistencia de 1k. La conexin
restante del led 1 se conecta a tierra
El led 2 ya estaba conectado en el sistema mnimo.
El programa:
//interrupciones:1.c
//Ejemplo interrupciones
#define fcy 16000000
//Bits de Configuracion
_FWDT(WDT_OFF);
int main(void);
void retardo_ms( unsigned int ms );
void confInterrup(void);
int main(void){
TRISD = 0xfdf7; // 1101 1111 0111
LATDbits.LATD3=1;
retardo_ms(120);
LATDbits.LATD3=0;
confInterrup();
while(1){ //Ciclo infitnito
}
}
void __attribute__((__interrupt__)) _INT0Interrupt(void){
LATDbits.LATD3=1;
retardo_ms(2000);
retardo_ms(2000);
LATDbits.LATD3=0;
IFS0bits.INT0IF = 0;
}
void __attribute__((__interrupt__)) _INT1Interrupt(void){
LATDbits.LATD9=1;
retardo_ms(2000);
retardo_ms(2000);
LATDbits.LATD9=0;
IFS1bits.INT1IF = 0;
}
void confInterrup( void ){
INTCON2bits.INT0EP = 1; //Interrupcion 0 Se activa en flanco negativo
INTCON2bits.INT1EP = 1; //Interrupcion 1 Se activa en flanco negativo
IPC0bits.INT0IP = 4; //Interrupcin 0, prioridad 4

IPC4bits.INT1IP = 6; //Interrupcin 1, prioridad 6
IEC0bits.INT0IE = 1; //Habilita interrupcin 0

IEC1bits.INT1IE = 1; //Habilita interrupcin 1
}
void retardo_ms( unsigned int ms ){
unsigned int periodo= 0;
/* ensure Timer 1 is in reset state */
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
periodo = ((fcy/256)*ms)/1000;
PR1 = periodo; //Set Timer 1 period register
}
El programa
El programa tiene una funcin que configura la interrupcin 0 (INT0) y la interrupcin 1 (INT1).
A INT0 la configura con prioridad 4 y a INT1 con prioridad 6.
La funcin principal tiene un ciclo infinito vaco (Sin instrucciones) que siempre se va a estar
ejecutando. En otras palabras la nica tarea que ejecuta el programa principal es estar dando
vueltas en un ciclo infinito. Pero cuando una interrupcin se activa, El cpu abandona el ciclo
infinito y atiende la interrupcin ejecutando el cdigo que contiene.
Al terminar esta prctica se recomienda hacer un reporte en el que se expliquen los resultados al
presionar en diferente orden los push-buttons 1 y 2..
Es importante comentar que estas son interrupciones externas. Tambin hay interrupciones
usadas por dispositivos como el timer, etc.
Fin de la prctica.
Proyectos:
Construir un robot seguidor de lneas

Prctica 6, el UART
El objetivo de esta prctica es que el estudiante aprenda el uso del UART.
El uart es un dispositivo ampliamente utilizado para la comunicacin serial asncrona. En esta

prctica interconectaremos dos 4013 a travs del uart.
40
35
34
24
28
39
38
37
33
31
30
29
27
25
23
21
36
32
26
22
Rx
Tx
dsPIC30F4013
17
13
11
12
14
16
18
20
10
15
19
2
6
7
1
4
5
3
8
9
35
34
24
40
28
39
38
37
33
31
30
29
27
25
23
21
36
32
26
22
Rx
Tx
dsPIC30F4013
17
13
10
11
12
14
16
18
20
15
19
7
6
2
8
1
9
3
Figura 6.1. No se muestran el resto de las conexiones para hacer el esquema fcil de entender.
Los leds se conectan en cada 4013 a los puertos RB1 y RB2, el push-button se conecta a RF0. El
Tx de un microcontrolador se conecta al Rx del otro microcontrolador. En ambos chips, se usa el
UART 1
Lista de material
Adems del material requerido para dos sistemas mnimos:
2 Push-button
4 Leds
4 Resistencias de 1k
Armado del circuito
Construir dos sistemas mnimos, cada uno en su propio Protoboard

Interconectarlos segn la figura 6.1
Conectar en cada microcontrolador en el puerto RF0 un push-button
Conectar en cada microcontrolador en los puertos RB1 y RB2 un led. Un extremo del led va a
tierra, y el otro extremo a una resistencia de 1 k. La resistencia va conectada a los puertos
El algoritmo:
Cuando en un microcontrolador se presione el push-button, se enva un 1 a travs del

uart1, y si no est presionado el push-buton, se enva un 2.
Cuando un microcontrolador reciba un byte, si ste byte es un 1 prende el led en RB1 y
apaga el led en RB2.
Cuando un microcontrolador reciba un byte, si ste byte es un 2 apaga el led en RB1 y
prende el led en RB2.
La configuracin del UART
Como se ve en los apuntes, el 4013, posee dos UARTS, para sta prctica usaremos el UART1, y
por lo tanto es el que vamos a configurar.
Velocidad de transmisin/recepcin (Baudrate)

El UART tiene un generado Baud rate que es programado con el registro U1BRG, el uno
despus de la U se refiere al UART1.
El U1BRG es un registro de 16 bits (0-65535). En este registro se pone un nmero calculado con
la siguiente ecuacin:
Baud rate = Fcy/(16*(BRG+1))
U1BRG = (Fcy/(16*Baud Rate))-1
Ejemplo:
Si necesitamos un baud rate de 9600 y el Fcy = 16 Mhz
U1BRG = (16000000/(16*9600))-1
U1BRG = 104.166-1 = 103.166
Como no se pueden poner decimales, entonces:

U1BRG = 103
Esto genera un error, el error obtenido es:

Error = (Baud rate calculado Baud rate deseado)/Baud rate deseado
Calcularemos el el baud rate obtenido
Baud rate =16000000/(16*(103+1))

Baudrate = 9615.38
Error = (9615.38-9600)/9600
Error = 0.160256 %

Otra manera de calcular el nmero a poner en el registro U1BRG es usando las tablas que se
encuentran en la hoja de datos de la familia, de las cuales h extrado un segmento y se puede ver
en la figura 6.2.
En las tablas completas se puede ver que con algunos Fcy se puede lograr cero error, pero a
cambio se reducen los mips. En aplicaciones en que es importante tener velocidades de
transmisin exactas, y no es crtico la velocidad de procesamiento, se puede usar el Fcy, para cero
error del Baud rate.
.Figura 6.2
U1BRG = 103; // Baudrate 9600 @ 16 Mhz Fcy

Configuramos el U1BRG para tener aproximadamente 9600 de velocidad
La configuracin siguiente tiene que ver con el modo de transmisin y se realiza usando el
registro U1MODE. Slo configuraremos las opciones usadas en esta prctica y que son 8 bits no
paridad y un bit de parada que es modo de transmisin ms usado y que tambin se le conoce
como N-8-1.
Como se puede ver en los apuntes, el bit 15 de U1MODE habilita el UART1, eso significa que
los otros dispositivos que comparten las mismas patitas quedan deshabilitados.
Los bits del 1 al 2 configuran el tamao en bits del byte y la paridad, como el byte lo
necesitamos de 8 bist y sin paridad, a estos bits les asignamos un cero.
Y por ltimo necesitamos un bit de alto, que se define en el bit cero del U1MODE.
Ya podemos configurar el U1MODE
U1MODE = 0x8000; // Se habilita el uart y N-8-1
Tambin podemos hacer la configuracin bit a bit, de la siguiente manera:

U1MODEbits.UARTEN = 1; // Se habilita el uart
U1MODEbits.PDSEL = 0; // 8 bits sin paridad
U1MODEbits.SETSEL = 0; // 1 bit de stop

Hasta este momento de la configuracin solo est habilitado y configurado el UART, es necesario
que si tiene datos, se ponga a transmitir.
El UART empieza a transmitir cuando se le asigna un uno a UTXEN (Bit 10) del registro
U1STA
U1STAbits.UTXEN = 1; // Habilita la transmisin
Con esto termina la configuracin
El programa:
/*
uasrt_1.c
Ejemplo de UART
*/
int configura_UART1();
int main(void);
int main(void){
char c1;
TRISB = 0x0000; //Todas son salida

TRISF = 0xFFFF; //Todas son entradas
configura_UART1();
while(1){
if(U1STAbits.URXDA==1){ // Hay datos disponibles en buffer de
recepcion?
c1 = U1RXREG; // Si es verdad, lee el dato
if(c1==1){ // Si es un 1
LATBbits.LATB1=1; // Prende RB1
LATBbits.LATB2=0; // Apaga RB2
}
if(c1==2){ // Si es un 2
LATBbits.LATB1=0; // Apaga RB1
LATBbits.LATB2=1; // Prende RB2
}
}
if(PORTFbits.RF0==0) // Si el pushboton est presionado
if(U1STAbits.UTXBF==0) // If transmit buffer is not full?
U1TXREG = 1; // Pone un 1 en el transmit
buffer
if(PORTFbits.RF0==1) // Si el pushboton es 1
if(U1STAbits.UTXBF==0) // Si hay espacio en el buffer de
transmision
U1TXREG = 2; // Pone un 2 en el buffer de
transmisin
}
}
int configura_UART1(){
U1BRG = 103; // Baudrate 9600 @ 16 Mhz Fcy
U1STA = 0; // Limpar registro de control y status
U1MODE = 0x8000; // Se habilita el uart y N-8-1

U1STAbits.UTXEN = 1; // Se habilita la transmisin
return 0;
}
Fin de prctica.
Proyectos sugeridos:
1. Construir un mdulo que tenga un microcontrolador y un LCD. La funcin de ste
modulo ser que despliegue en el LCD los caracteres recibidos en el puerto serie.
2. Disear un mdulo que tenga un microcontrolador y como actuadores dos motores a

pasos y con ello construir un brazo de robot bsico. Este modulo se conectar a la PC a
travs del puerto serie. Escribir un programa en la PC que permita controlar la posicin.
Es importante que se realicen los dos proyectos

Prctica 7, construir un voltmetro digital usando el ADC

El objetivo de esta prctica es que el estudiante aprenda el uso del convertidor analgico-digital
(DAC) bsico.
Conceptos bsicos:
El 30F4013 tiene un DAC de 12 bits, este convertidor est orientado a precisin ms que a
velocidad. En contraste la serie 30F dispone de microcontroladores con DACs de 10 bits. Estos
convertidores analgico-digitales estn orientados a velocidad.
Tiempo de Tiempo de
muestreo conversin
Figura 7.1: En la conversin analgica-digital, el convertidor distingue dos tiempos. El tiempo de
muestreo que es el tiempo que dura le convertidor conectado a la seal, y el tiempo de
conversin, que es el tiempo que le toma al convertidor convertir la seal muestreada a digital.
Existen una buena cantidad de formas de hacer la conversin.

El siguiente ejemplo es:
Muestreo de una sola entrada analgica
Inicio del muestreo manual
Duracin del muestreo manual
Inicio de la conversin manual.
La referencia positiva y negativa se toma de la alimentacin
En otras palabras todo el proceso es totalmente manual.
Configuracin:
Primero definimos como va a iniciar el muestreo, tenemos dos opciones para que comience el
muestreo, cuando ponemos el bit SAMP =1, o que el muestreo inicie inmediatamente despus
que la conversin finaliza. Esta configuracin se define con el bit ASAM del registro ADCON1
bit 2 ASAM: bit de muestreo automtico de A/D
1= El muestreo comienza inmediatamente despus de que la ltima conversin se ha

completado. El bit SAMP automticamente se pone a uno
0= El muestreo comienza hasta que el programa ponga el bit SAMP a uno.

Definiremos al bit SAMP como control del inicio del muestreo.
ADCON1bits.ASAM =0; //El muestreo inicia cuando el bit SAMP == 1
Ahora definiremos de que manera finaliza el muestreo e inicia la conversin.

El registro ADCON1, contiene un conjunto de bits, que se llaman SSRC, estos bits se usan para
configurar la fuente del inicio de la conversin. En seguida tenemos las opciones de estos bits.
bit 7-5 SSRC<2:0>: bits de seleccin de fuente de inicio de la conversin
111 = contador interno termina el muestreo y comienza la conversin (auto conversin)

110 = reservado
101 = reservado
100 = reservado
011 = Intervalo PWM para control de motores termina el muestreo y comienza la
conversin
010 = comparacin del timer 3 termina el muestreo y comienza la conversin
001 = transicin activa en el pin INT0 termina el muestreo y empieza la conversin
000 = limpiando el bit SAMP termina el muestreo y comienza la conversin
Elegiremos el bit SAMP como fuente de disparo de fin del periodo de muestreo e inicio del
periodo de conversin.
ADCON1bits.SSRC =0; //Cuando el bit SAMP == 0, termina el muestreo
// e inicia la conversin.
Se tienen 2 conjuntos de entradas, MUXA y MUXB, Para esta prctica utilizaremos el MUXA.
Por lo tanto estableceremos la configuracin del MUXA, para realizar esta configuracin se usa
el registro ADCHS.
bit 4 CH0NA: Determina la entrada negativa del canal 0 en el MUXA.
1 = Entrada negativa del canal 0 es AN1

0 = Entrada negativa del canal 0 es VREF-
Estableceremos como entrada negativa a Vref- en el MUXA

ADCHSbits.CH0NA =0; // Entrada negativa del canal 0 es VREF-
En seguida determinamos la entrada positiva del MUXA

bit 3-0 CH0SA<3:0>: Determina la entrada positiva del canal 0 en el MUXA.
1111 = Entrada positiva del canal 0 es AN15

Establecemos como entrada positiva la patita RB8/AN8

ADCHSbits.CH0SA =8; // Entrada positiva del canal 0 es 8

Se pueden seleccionar un conjunto de hasta 16 entradas a muestrear de manera secuencial

(Scanning), para ello se usa el registro ADCSSL. Pero en sta prctica no vamos a utilizar esta
forma de muestreo, por lo tanto ponemos este registro a cero.
Adems de determinar cero entradas para entrada secuencial, tambin deshabilitamos el muestreo
secuencial.
ADCSSL = 0; //Cero entradas para muestreo secuencial (scanning)
Adems de determinar cero entradas para entrada secuencial, tambin deshabilitamos el muestreo
secuencial.
ADCON2bits.CSCNA =0; //Muestreo secuencial (Scan) deshabilitado.
Ahora se elegirn cuales son los voltajes de referencia positiva y negativa
bit 15-13 VCFG<2:0>: bits de configuracin de voltaje de referencia.
Se ponen como referencia positiva AVdd y como referencia negativa AVss, que son las
alimentaciones del mdulo ADC.
ADCON2bits.VCFG =0; //Referencia positiva=AVdd, Referencia negativa=AVss.
Los resultados del la conversin se guardan en el registro ADCBUF, que tiene 16 palabras (16
bits). Las palabras se llaman ADCBUF0, ADCBUF1...ADCBUF15. Este registro para algunas
aplicaciones muy particulares se puede dividir en 2 de registros de 8 palabras.
Para esta aplicacin definimos este registro sin divisin.

ADCON2bits.BUFM =0; //Configurado como un buffer de 16 palabras.
El ADC genera una interrupcin cada n conversiones. Para especificar n, se usa el conjunto de
bits SMPI en ADCON2. Cuando se necesita que el resultado se guarde en la primera palabra
(ADCBUF0), luego la 2 conversin en ADCBUF1, hasta ADCBUF(n-1). Para ir llenando el
ADCBUF, se debe generar una interrupcin cada n conversiones.
Establecemos que cada que se genere una interrupcin despus de cada conversin. De esta
forma, el resultado de cada cada una de las conversiones se guarda en ADCBUF0.
ADCON2bits.SMPI =0; //Despus de una conversin se genera la interrupcin.
Como se tienen dos conjuntos de entradas, el MUXA y el MUXB, se puede elegir que se tomen
muestras en A y luego en B, esto se hace con el bit ALTS.
Pero como solo usamos el MUXA, deshabilitamos el muestreo alternante.

ADCON2bits.ALTS =0; //Slo se muestrea el MUXA.

Con esto se termina de configurar el registro ADCON1. Se puede observar que para muestreo
manual solamente se usa una entrada analgica, adems podemos observar que todo ADCON1 es
cero, entonces si lo ponemos a cero, no es necesario configurar cada conjunto de bits, sin
embargo, en este ejemplo lo configuramos por partes por cuestin didctica.
El convertidor ADC usa un reloj que puede ser derivado del reloj del sistema o del reloj interno
del chip. Para elegirlo se usa el bit ADRC localizado en el ADCON3.
Hacemos la configuracin, para que el reloj del ADC sea derivado del reloj principal del sistema.
ADCON3bits.ADRC =0; //Reloj del ADC es derivado del reloj sistema
Tad = Periodo del reloj del ADC, que se deriva del reloj principal o del reloj interno, pero tiene
un mnimo, que para el 4013 el Tad debe ser mayor a 667 ns.
Al definir el Tad debemos tener mucho cuidado de cumplir con el lmite. Por ejemplo si elegimos
un Tad = 2 Tcy, y tenemos un Fosc = 64Mhz, el Tad = 2*62.5ns = 125ns, que es mucho menor
al mnimo permitido.
Con 32 Tcy, obtenemos un Tad de 32*62.5 = 2000 ns. Que ya est dentro del lmite de 667 ns,
pero que puede ser alto para nuestra aplicacin.
La menera correcta de calcular el Tad mnimo permitido es con la siguiente ecuacin:

ADCS=2*Tad/Tcy -1
Ejemplo:
Tad = 667ns
Tcy = 33.33 ns
667/33.33 = 20.012
20.012*2 = 40.024
40.024-1
= 39
Por lo tanto en ADCS se pone un 39
Ejemplo para un Tcy = 62.5 ns (Fosc=64Mhz)

667/62.5= 10.672
10.672*2= 21.344
21.344 -1 = 20.344, para redondear lo dejamos en 21
ADCON3bits.ADCS =21; //Tad = (21+1)*.5 Tad = 11 Tcy = 687.5
Como se puede observar, el Tad calculado es el mnimo posible que cumple la especificacin.
El registro ADCON3 contiene el conjunto de bits SAMC, usados para especificar el tiempo que
dura el muestreo para automatizacin de este proceso, pero como este ejemplo es una conversin
analgicadigital manual, pues estos bits no los usamos. En otra prctica retomaremos la
configuracin de estos bits.

Construccin del prototipo de prueba.
Material
Adems del material del sistema mnimo:
1 Resistencia variable de 10 k, se recomienda de precisin.

1 Dispositivo de visualizacin para poder observar los resultados. Este dispositivo lo
podemos construir en el mismo protoboardcon un LCD. En ese caso se necesita el LCD
y el cdigo para su control. Otra opcin puede ser mostrar el resultado en forma binaria
usando leds. En esta prctica usaremos un LCD que recibe los datos a mostrar a travs del
UART de un microcontrolador.
AVSS
AVDD + +
+v
LCD
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
dsPIC30F4013
17
10
11
12
13
14
15
16
18
19
20
2
6
7
1
4
5
10K 1k Led 1
1k
+ GND
+v
Figura 7.2. Diagrama del circuito de la prctica. Se puede observar como el mdulo LCD se
conecta al circuito a travs del uart2.
El circuito se arma de acuerdo a la figura 7.2. El mdulo del LCD es un proyecto anterior que ya
debe estar bien depurado.
Es importante observar que se han conectado AVdd y AVss al voltaje positivo y negativo
respectivamente. AVdd y AVss son la alimentacin del mdulo ADC
El programa:
/* adc_12bits_1.c
Usa UART2
Muestrea el canal AN8/RB8
*/
#include <math.h>

#include <stdio.h>
#include <string.h>

_FWDT(WDT_OFF);

int main(void);
void retardo_us( unsigned int us );
void adc_ini(void);
void muestra_en_lcd_remoto(unsigned int dato);
void uart_write(unsigned char dato);
void configura_UART2();
int main(void){
unsigned int letra=0, i=0, ADCValue=0, t;
float volts;
TRISD=0xFFF7; //0111 Solo RD3 como salida
LATDbits.LATD3=1; //Solo se prende el led RD3
retardo_ms(100);
LATD=0x0000; //Apaga el led RD3
retardo_ms(100);
LATD=0x0008; //Solo se prende el led RD3
retardo_ms(5);
configura_UART2();
adc_ini();
ADCON1bits.ADON = 1; //Prende ADC
uart_write(254); // c'odigo para limpiar lcd
while(1){
ADCON1bits.SAMP = 1; //Inicia muestreo
retardo_ms(1);
ADCON1bits.SAMP = 0; //Finaliza muestreo
while(!ADCON1bits.DONE); //Se ha realizado la conversin?
ADCValue = ADCBUF0; //Si entonces copia el valor ADCValue
//Convierte el ADCvalue en su equivalente en voltaje

volts = (ADCValue/4096.0)*500;
uart_write(128); // 0x80= Comando para la LCD = Home
muestra_en_lcd_remoto(volts);
retardo_ms(50); //Para que se pueda ver en LCD
}
}
void muestra_en_lcd_remoto(unsigned int dato){
unsigned int miles=0, centenas=0, decenas=0;
unsigned char digito= '0';
miles = dato/1000;
digito = miles+48;
uart_write(digito);
retardo_ms(5);
dato = dato-miles*1000;
centenas = dato/100;
digito = centenas+48;
uart_write(digito);

retardo_ms(5);
dato = dato-centenas*100;
decenas = dato/10;
digito = decenas+48;
uart_write(digito);
retardo_ms(5);
dato = dato-decenas*10;
digito = dato+48;
uart_write(digito);
retardo_ms(5);
}
void adc_ini(void){
//Configura el modulo A/D
TRISB = 0xFFFF; //Todas Entradas
ADPCFG = 0x0000; //Todas Entradas Analgicas
//ADCON1 = 0x0000;
ADCON1bits.SSRC =0; //Cuando bit SAMP == 0, termina el muestreo
// e inicia la conversin
ADCHSbits.CH0SA =8; // Entrada positiva del canal 0 es RB8/AN8
//ADCHS = 0x0008; //RB8/AN8 es entrada analogica
ADCSSL = 0; //No hay entradas para muestreo secuencial
ADCON2bits.CSCNA =0; //Muestreo secuencial (Scan) deshabilitado.
ADCON2bits.VCFG =0; //Referencia positiva=AVdd, Referencia
// negativa=AVss.
ADCON2bits.SMPI =0; //Despus de una conversin se genera la int.

ADCON3bits.ADCS =21; //Tad = (21+1)*.5 Tad = 11 Tcy = 687.5
//ADCON3 = 0x0002; //muestreo manual(Por tiempo) Tad=2Tcy

//ADCON2 = 0;
}
void uart_write(unsigned char dato){
while(U2STAbits.UTXBF!=0);
U2TXREG = dato; // Pone a dato en el buffer de transmisin
}
void configura_UART2(){
// U1BRG = 0x0067; // 8 bits, sin paridad, 9600 bps, dec=103
// Baudrate(103) 9600 @ 16 Mhz Fcy
U2BRG = 103; // 8 bits, sin paridad, 9600 bps, dec=71

// Baudrate(71) 9600 @ 11.0592 Mhz Fcy
U2STA = 0; // Limpiar registro de control y status
U2MODE = 0x8800; // N-8-1
U2STAbits.UTXEN = 1; // Enable transmit
}
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;

}
void retardo_us( unsigned int us ){
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
periodo = (fcy*us)/1000000;
}
Fin de prctica
Proyectos:
1. Construir un termmetro digital usando el LM35 cualquier otro sensor de temperatura y
mostrar la temperatura en un LCD
2. Construir un mdulo que tenga un microcontrolador y un sensor de temperatura (LM35).

Este modulo se conectar a la PC a travs del puerto serie. Escribir un programa en la PC
que despliegue la temperatura.

Prctica 8, haciendo mltiples muestras.
El objetivo de esta prctica es que el estudiante experimente con algunas caractersticas

avanzadas del convertidor analgico-digital
Para esta prctica usaremos el microcontrolador 30F3011 que est diseado para control de
motores y posee adems de los mdulos de control de motores un convertido analgico de 10
bits.
Material
UART de un microcontrolador.
Para el armado seguiremos el diagrama de la figura 8.1. Conectaremos a los puertos del
RB0/AN0 al RB8/AN8 aquellos voltajes que pretendamos medir y observar en la LCD. En el
diagrama se puede observar que RB0/AN0, RB1/AN1, RB2/AN2 y RB7/AN7 estn conectados
a la alimentacin positiva, y RB3/AN3, RB4/AN4, RB5/AN5 y RB8/AN8 estn conectados a
tierra. RB8/AN8 est conectado a un divisor de voltaje.
AVSS
AVDD + +
+v
LCD
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
dsPIC30F3011
17
10
11
12
13
14
15
16
18
19
20
2
6
7
1
3
4
5
8
9
10K 1k Led 1
1k
+ GND
+v
Figura 8.1

Configuracin del ADC:



110 = reservado
101 = reservado
100 = reservado
conversin
el registro ADCHS.




No establecemos como entrada positiva

//ADCHSbits.CH0SA =8; // Entrada positiva del canal 0 es 8

(Scanning), para ello se usa el registro ADCSSL. Vamos a definir las 16 entradas
ADCSSL = 0xFFFF; //Entradas a scanning 16.
Adems de determinar las entradas secuenciales, tambin habilitamos el muestreo secuencial.

ADCON2bits.CSCNA =1; //Muestreo secuencial (Scan) habilitado.

ADCON2bits.SMPI =0; //Despus de una conversin se genera la interrupcin.


al mnimo permitido.

ADCS=2*Tad/Tcy -1
Ejemplo:
Tad = 667ns
Tcy = 33.33 ns
667/33.33 = 20.012
20.012*2 = 40.024
40.024-1
= 39

y un Tad mnimo de 84 ns (Ver hoja de datos del 30F3011, seccin 24, tabla 24-40)
84/62.5= 1.344
1.344*2= 2.688
ADCON3bits.ADCS =2; //Tad = (2+1)*.5 Tad = 1.5 Tcy = 93.75

dura el muestreo para automatizacin de este proceso, pero como este ejemplo es una conversin
analgicadigital manual, pues estos bits no los usamos. En otra prctica retomaremos la
configuracin de estos bits.
El programa:
/* adc_10bits_5.c
Status = Ok.
Programa ejemplo de 10 bits
Este programa muestrea(SCANNING) de AN0-AN15
De forma secuencial y a traves de SH0
Muestra el resultado en LCD remoto de 6 valores
El inicio de muestreo = Manual
Finalizacin de muestreo = Manual
Usa UART2, para que quede libre PGC y PGD
Caracteres de control de la LCD remota

c1>127 = comando
128 = home (Primera posici'on primera linea) = (0x80)
129=2a, 130=3a ... 147=20a Para primera linea
192 = primera posic'on 2a linea (0xC0)
193 =2a, 193=3a ... 221=20a.
c1=254 = limpiar display
*/
#include <math.h>
#include <stdio.h>
#include <string.h>

_FWDT(WDT_OFF);

int main(void);
void adc_ini(void);
void mensaje_uart(char texto[]);
int main(void){
unsigned int letra=0, i=0, ADCValue=0,ADCValue2=0, t;

float volts;

retardo_ms(100);

retardo_ms(100);
retardo_ms(5);
configura_UART2();
adc_ini();
uart_write(254); // cdigo para limpiar lcd
volatile unsigned int *ADC16Ptr;
while(1){
IFS0bits.ADIF = 0; //Limpia bandera
ADCON1bits.SAMP = 1; //Inicia muestreo
retardo_ms(1);
while(IFS0bits.ADIF); //Se han realizado las 16
conversiones?
ADCON1bits.SAMP = 0; //Finaliza muestreo
uart_write(128);
muestra_en_lcd_remoto((ADCBUF3/1024.0)*500);
uart_write(133);
uart_write(138);
uart_write(192);
uart_write(197);
uart_write(202);
}
}
miles = dato/1000;
digito = miles+48;
uart_write(digito);
retardo_ms(5);
uart_write(digito);
retardo_ms(5);
decenas = dato/10;
uart_write(digito);
retardo_ms(5);
digito = dato+48;
uart_write(digito);
retardo_ms(5);
}
void mensaje_uart(char texto[]){
int i;

for(i=0;i<strlen(texto);i++)
uart_write(texto[i]);
}
void adc_ini(void){
TRISB = 0xFFFF; //Todas Entradas
ADPCFG = 0x0000; //Todas Analogicas
ADCON1 = 0x0000; //Nos aseguramos que ADCON1 est en reset

ADCON2 = 0; //Nos aseguramos que ADCON2 est en reset
ADCSSL = 0xFFFF; //Entradas a scanning 16
ADCON2bits.CSCNA =1; //Muestreo secuencial (Scan) habilitado
negativa=AVss.
ADCON2bits.BUFM =0; //Configurado como un buffer de 16
palabras.
ADCON2bits.SMPI = 0xF; //Interrupcin cada 16 muestras
ADCON3bits.ADRC =0; //Reloj del ADC es derivado del reloj
sistema
}
U2TXREG = dato; // Pone a dato en el buffer de transmision
}
U2BRG = 103; // Baudrate(71) 9600 @ 11.0592 Mhz Fcy
U2MODE = 0x8000; // N-8-1
U2STAbits.UTXEN = 1; // Activa transmisin
}
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
}
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;

}
Fin de prctica

Prctica 9, haciendo mltiples muestras con el ADC de forma

totalmente automtica.
El objetivo de esta prctica es que el estudiante se entrene en el uso del convertidor analgico-
digital haciendo mltiples muestras, con todo el proceso totalmente automtico. Esta es la manera
ms adecuada para realizar conversiones analgico-digitales donde se muestrean mltiples
seales y se busca alto desempeo.
Tambin usaremos el microcontrolador 30F3011 que est diseado para control de motores y
posee adems de los mdulos de control de motores un convertido analgico de 10 bits bastante
rpido, Tad mnimo = 84 ns.
Material
UART de un microcontrolador (mdulo construido como proyecto).
Para el armado seguiremos el diagrama de la figura 8.1 (De la prctica anterior). Conectaremos a
los puertos del RB0/AN0 al RB8/AN8 aquellos voltajes que pretendamos medir y observar en la
LCD. En el diagrama se puede observar que RB0/AN0, RB1/AN1, RB2/AN2 y RB7/AN7 estn
conectados a la alimentacin positiva, y RB3/AN3, RB4/AN4, RB5/AN5 y RB8/AN8 estn
conectados a tierra. RB8/AN8 est conectado a un divisor de voltaje.
Configuracin del Convertidor analgico-digital.

ADCON1bits.ASAM =1; //El muestreo inicia de forma automtica



110 = reservado
101 = reservado
100 = reservado
conversin
ADCON1bits.SSRC =0b111; //Contador interno termina muestreo e inicia
//conversin
el registro ADCHS.




No establecemos como entrada positiva

//ADCHSbits.CH0SA =8; // Entrada positiva del canal 0 es 8

(Scanning), para ello se usa el registro ADCSSL. Vamos a definir las 16 entradas
Adems de determinar las entradas secuenciales, tambin habilitamos el muestreo secuencial.

ADCON2bits.CSCNA =1; //Muestreo secuencial (Scan) habilitado.


ADCON2bits.SMPI =0xF; // Una interrupcin cada 16 muestras


al mnimo permitido.

ADCS=2*Tad/Tcy -1
Ejemplo:
Tad = 667ns
Tcy = 33.33 ns
667/33.33 = 20.012
20.012*2 = 40.024
40.024-1
= 39

y un Tad mnimo de 84 ns (Ver hoja de datos del 30F3011, seccin 24, tabla 24-40)
84/62.5= 1.344
1.344*2= 2.688
dura el muestreo para automatizar este proceso. En la siguiente figura se muestra un fragmento
de la hoja de datos.
ADCON3bits.SAMC = 0b11111; //Finaliza muestro de forma automtica cada 31Tad
El programa:
/* adc_10bits_6.c
Status Ok
Programa ejemplo de 10 bits

Usa UART2, para que quede libre PGC y PGD
Muestrea 16 canales
De forma secuencial y a traves de SH0 de forma automtica
caracteres de control de la LCD remota

c1>127 = comando
128 = home (Primera posici'on primera linea) = (0x80)
129=2a, 130=3a ... 147=20a Para primera linea
192 = primera posic'on 2a linea (0xC0)
193 =2a, 193=3a ... 221=20a.
c1=254 = limpiar display
*/
#include <math.h>
#include <stdio.h>
#include <string.h>

_FWDT(WDT_OFF);

int main(void);
void adc_ini(void);
void mensaje_uart(char texto[]);
int main(void){
unsigned int letra=0, i=0, ADCValue=0, t;

float volts;

retardo_ms(100);
retardo_ms(100);
retardo_ms(5);
configura_UART2();
adc_ini();
uart_write(254); // c'odigo para limpiar lcd
while(1){
IFS0bits.ADIF = 0;
while(IFS0bits.ADIF); //Se han realizado las muestras?
uart_write(128);
uart_write(133);

uart_write(138);
uart_write(192);
uart_write(197);
uart_write(202);
LATDbits.LATD3 = 0;
retardo_ms(1);
LATDbits.LATD3 = 1;
}
}
miles = dato/1000;
digito = miles+48;
uart_write(digito);
retardo_ms(5);
uart_write(digito);
retardo_ms(5);
decenas = dato/10;
uart_write(digito);
retardo_ms(5);
digito = dato+48;
uart_write(digito);
retardo_ms(5);
}
void mensaje_uart(char texto[]){

int i;
for(i=0;i<strlen(texto);i++)
uart_write(texto[i]);
}
void adc_ini(void){
TRISB = 0xFFFF; //Todos los pines son entradas

ADPCFG = 0x0000; //Todas Analogicas
ADCON1bits.ASAM = 1; //Inicia muestreo de manera automtica,

//sin usar el bit SAMP
ADCON1bits.SSRC = 0b111; //Contador interno finaliza muestreo
//y comienza conversi'on (Autoconversion)

ADCON2bits.CSCNA = 1; //Activa el scanning de entradas
//negativa=AVss.
ADCON2bits.BUFM =0; //Configurado como un buffer de 16
//palabras.
ADCON2bits.SMPI = 0xF; //Una interrupcin cada 16 muestras
ADCON3bits.ADRC =0; //Reloj del ADC es derivado del reloj
// sistema
ADCON3bits.ADCS =2; //Tad =(2+1)*.5 Tad = 1.5*Tcy = 93.75

ADCON3bits.SAMC = 0b11111; //Finaliza muestro de forma automtica
// cada 31Tad
}

U2TXREG = dato; // Pone a dato en el buffer de transmisin
}
U2BRG = 103; // Baudrate 9600 @ Fcy=16Mhz
U2MODE = 0x8000; // N-8-1
U2STAbits.UTXEN = 1; // Activa transmisin
}
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
}
T1CON = 0;
TMR1 = 0;
IPC0bits.T1IP = 1;
}
Fin de prctica
Proyectos sugeridos:
Mejorar el robot seguir de lneas, para que sea capaz de aprender y adaptarse a diversas
intensidades de luz.

Prctica 10, el mdulo PWM

El objetivo de esta prctica es que el estudiante aprenda el uso del mdulo PWM.
El mdulo de control de motores mediante PWM simplifica la tarea de generar pulsos modulados
en amplitud. El dsPIC30F3011 posee tres canales PWM cada uno con dos salidas. La familia 30F
posee varios modos de operacin, en sta prctica usaremos el modo Edge Aligned con Free
running, ver figura 10.1. En este modo el funcionamiento es como sigue:
Se guarda un nmero en el registro PTPER, este nmero corresponde al periodo de la seal
generada y se calcula de acuerdo a la siguiente ecuacin Fcy/(Fpwm*PTMR scaler)-1.
En los registros PDCx se guarda un nmero que corresponde al ciclo de trabajo (duty cycle)
deseado.
El temporizador genera pulsos que se van contando y almacenando en PTMR. La cuenta se
realiza de cero hacia hasta alcanzar el nmero guardado en el registro PTPER. Cuando la cuenta
coincide con el nmero almacenado en algn registro PDCx, en la patita de salida de ese canal x,
el voltaje cae a cero y as permanece. Cuando el periodo comienza de nuevo, la seal se eleva a
uno lgico (segn el voltaje de alimentacin), la figura 10.1 puede ayudar a entender este
proceso.
Edge Aligned PWM
PTPER
PDC1
PDC2
Time
PWM1H
PWM2H
.
Figura 10.1
La prctica consiste en controlar un motor servo de marca parallax, aunque puede funcionar para
motores servo de otros marcas u otros modelos, slo es necesario ajustar el programa a las nuevas
especificaciones.
El motor servo parallax cuando recibe un ancho de pulso de trabajo de 1.5 ms se detiene frenado,
es decir la electrnica de control del motor hace que el motor haga fuerza para mantenerse en esa
posicin. Sin seal tambin se detiene pero sin freno.

Con 1.7 ms se obtiene la mxima velocidad de giro en un sentido y con 1.3 ms se obtiene la
velocidad mxima de giro en sentido contrario.
Material adicional al sistema mnimo
1 motor servo
2 push-buttons
Algoritmo
Que el programa enve un pulso pwm de 20 ms (PWM3H), cambiando el ciclo de trabajo desde 0
a 2 ms por medio de dos push buttons. El push-button 1 aumenta el ciclo de trabajo de cero hasta
930 y el push-buton 2 reduce el ciclo de 930 hasta cero, para generar ciclos de trabajo de 0 ms
hasta 1.7 ms.
Construccin del prototipo de prueba:
Estos pasos suficientes cuando ya se tiene listo el sistema mnimo:

1. Se conectan los push-buttons a RD0 y RD1 (Ver figura 10.2)
2. Se conecta el motor a la alimentacin
3. Se conecta el cable de seal a la patita PWM3H
+
+v
40
39
PWM1L 38
PWM1H 37
PWM2L 36
6 PWM2H 35
7 PWM3L 34
8 PWM3H 33
32
31
30
29
28
27
26
25
24
23
22
21
dsPIC30F3011
17
10
11
12
13
14
15
16
18
19
20
2
1
4
5
10K Led 1
1k
+
+v
GND
Figura 10.2

Inicializacin del mdulo PWM:
El registro PTCON controla el tiempo base del mdulo PWM
El bit PTEN(15) habilita el timer para que empiece a contar.
Que el tiempo base empiece a funcionar

PTCONbits.PTEN = 1; //PWM time base is ON
El bit PTSIDL(13) es para configurar si el mdulo funciona en modo de ahorro de energa

idle. Para ms informacin sobre los modos de ahorro de energa ver la seccin 10 (Watch dog
time and saving modes) de la hoja de datos de la familia 30F
Lo configuramos para que continu funcionando en modo idle

PTCONbits.PTSIDL = 0; //PWM time base runs in CPU Idle mode
El conjunto de bits PTOPS (7-4), son usados para definir el valor del postscaler, generalmente
estos bits se usan para cuestiones muy particulares. En esta prctica usaremos un postcaler 1:1
PTCONbits.PTOPS = 0b0000; //Postcaler 1:1
Los bits PTCKPS(3-2) se utilizan para establecer el prescaler(Divisor de frecuencia),

definiremos un prescaler de 1:64
PTCONbits.PTCKPS = 0b11; //Prescaler = 1:64
Y por ltimo tenemos los bits PTMOD(1-0) que definen el modo. El modo usado es free
running mode
PTCONbits.PTMOD = 0b00; //Free mode
El siguiente registro a configurar es PTMR.
El bit PTDIR = determina la direccin de conteo y es de solo lectura.
El registro PTMR guarda el conteo. Para aseguararnos que empiece en un estado de reset, lo
fijamos a cero.
PTMRbits.PTMR = 0; //Time base count value, asegurar el estado de reset
Configurar el periodo:
El periodo est en funcin del Fcy y del prescaler. Para este ejemplo se necesita un periodo de 20
ms, y debido a que en la ecuacin el periodo est expresado en frecuencia, hacemos la
conversin.
Fpwm = 1/0.020 = 50
Ppwm = 50
PTPER = Fcy//(Fpwm*Prescaler))-1
PTPER = (16000000/(50*64))-1
PTPER = 4999
PTPER = 4999; //Periodo = (Fcy/(Fpwm*Prescaler))-1=(fcy/(50*64))-1

Ya slo falta definir el ciclo de trabajo para terminar la inicializacin:
Como la resolucion del ciclo de trabajo = Fcy/2, entonces
Ciclo de trabajo = 2*PTPER*porcentaje
En este caso como necesitamos un ciclo de trabajo expresado en ms no en porcentaje

(1.7ms/20 ms)*4999 = 425,
Ciclo de trabajo = 425*2 = 850
PDC3 = 850; //Duty cycle = 1.7ms
Ahora configuraremos el canal adecuado PWM
Los bits PEMODx especifca el modo de funcionamiento del par de salidas del canalx, este modo
puede ser en modo independiente en modo complementario. En modo independiente cada
salida PWMxL y PWMxH es independiente entre s, y en modo complementario, cuando una
est en alto, la otra est en bajo. Para el modo complementario es necesario configura el tiempo
muerto para evitar que en un instante de tiempo una seal estar bajando y la otra subiendo al
mismo tiempo.Para esta prctica usaremos el modo independiente
PWMCON1bits.PMOD3 = 1; //Modo independiente
El conjunto de bits PENxH y PENxL se usan para habilitar deshabilitar las

salidas del canal PWMx, si se les asigna un uno, la salida es habilitada y esa
patita es controlada por el mdulo PWM. Si se le asigna un cero, la salida es
deshabilitada y queda fuera del control de PWM.
Entonces habilitamos las patitas que nos interesan de canal 3 del mdulo PWM y
las que no las deshabilitamos.
PWMCON1bits.PEN3L = 0; //Se deshabilita la salida PWM3L
PWMCON1bits.PEN3H = 1; //Se habilita la salida PWM3H
El mdulo PWM posee OVDCON que permite que los valores generados por el propio PWM
sean ignorados y sustituidos por otros (Override). El conjunto de bits POVDxHy POVDxL
permiten detreminar que salida est bajo el control de PWM y cuales son sustituidos por
POVDxx. No usaremos la sustitucin de valores.
OVDCONbits.POVD3H = 1; //PWM3H no es sustituida por POUT4H
El programa:
/* pwm03.c
*/
//Bits de Configuracion
_FWDT(WDT_OFF);
//Variables globales
long fcy = 16000000;
int main(void);

void retardo120ms(void);
void init_pwm(void);
int main(void){
int t;
TRISF = 0xFFFF; //Todo el puerto F es entrada
TRISB=0; //Todos los pines puerto B son salidas
TRISD=0xFFFB; // Solo RD2 como salida
init_pwm();
while(1){
if(PORTDbits.RD0==0 && PDC3<=950){
retardo120ms();
PDC3 += 50;
}
if(PORTDbits.RD1==0 && PDC3>=50){
retardo120ms();
PDC3 -= 50;
}
}
}
void init_pwm(void){
PTCONbits.PTEN = 1; //PWM time base is ON
PTCONbits.PTSIDL = 0; //PWM time base runs in CPU Idle mode
PTCONbits.PTOPS = 0b0000; //Postcaler 1:1
PTCONbits.PTCKPS = 0b11; //Prescaler = 1:64
PTCONbits.PTMOD = 0b00; //Free mode
PTMRbits.PTMR = 0; //PTMR es puesto a cero
PTPER = 4999; //Periodo = (Fcy/(Fpwm*Prescaler))-1
//Periodo=(fcy/(50*64))-1
//periodo = 20ms
//Config PWM3
PWMCON1bits.PMOD3 = 1; //Modo independiente
PWMCON1bits.PEN3L = 0; //Salida PWM3L deshabilitada
PWMCON1bits.PEN3H = 1; //Salida PWM3H habilitada
OVDCONbits.POVD3H = 1; //PWM3H no es sustituida por POUT4H
/* Si quisieramos configurar PWM2 solo agregamos el cdigo

de configuracin.
Este segemento de cdigo es slo como ejemplo
y por eso est comentado
PWMCON1bits.PEN2L = 0;
PWMCON1bits.PEN2H = 1;
PWMCON1bits.PMOD2 = 1;
OVDCONbits.POVD2H = 1;
OVDCONbits.POVD2L = 0;
*/
}
void retardo120ms( void ){

T1CON = 0;
TMR1 = 0;

IPC0bits.T1IP = 1;
PR1 = 0x1DC4; //Set Timer 1 period register
}
Fin de prctica
Proyectos:
Mejorar el robot seguidor de pistas con la posibilidad de modificar las velocidades de los motores
usando PWM
Proyecto Final
Con los conocimientos adquiridos con este laboratorio se pueden ejecutar diversos proyectos
finales con alto grado de complejidad, algunos pueden ser.
Control de dispositivos electrnicos de manera inalmbrica usando bluetooth

Control de dispositivos electrnicos de manera inalmbrica usando zigbee
Diseo y construccin de filtros de seales de audio
Robots luchadores de zumo
Etc.
Nota final:
Este manual contiene 10 prcticas de laboratorio completas y alrededor de doce proyectos

sugeridos ms 4 proyectos finales dando un total de 16 proyectos y 10 prcticas con lo que
tenemos 26 trabajos de laboratorio. Este material debera ser suficiente para un curso de
licenciatura, sin embargo hay muchos mdulos de los dsPICS que no se han tocado, por ejemplo
el protocolo CAN usado en la electrnica del automvil, Los encoders usados en el control de
motores, algunos protocolos de comunicaciones como el I2c, etc. y tampoco se incluye el
procesado digital de seales. Pero que si se incluyera todo ese material ya no sera suficiente un
semestre, tal vez ni dos, es por ello que slo se incluyeron diez prcticas.

Manual Microcontroladores

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Manual Microcontroladores

Caricato da

Copyright:

Formati disponibili

Universidad Autnoma de San Luis Potos

Manual de Prcticas de Laboratorio de la

Con los DsPICs de la serie 30F

Dr. J. Jess Acosta Elas

J. Jess Acosta Elas 2

La motivacin de escribir este manual de prcticas de laboratorio es proporcionar al estudiante un

El material contenido en este documento es el resultado de la experiencia en desarrollo de

Este manual no proporciona informacin terica de electrnica, de programacin ni de la teora

Breve descripcin de un microcontrolador

J. Jess Acosta Elas 3

J. Jess Acosta Elas 4

Armado del sistema (ver la figura 1.1)

Ya que se tiene armado el hardware sistema, es momento de escribir el programa. Es importante

J. Jess Acosta Elas 5

Creacin del programa

Creamos un proyecto con el programa MPLAB de Microchip (Ver capitulo 3 de los

Creamos un nuevo archivo con el nombre p01.c, con el siguiente contenido:

J. Jess Acosta Elas 6

//************* BITS de configuracin ********************

int main(void); //Prototipo funcin main

//************** Programa principal **********************

Carga del programa en el microcontrolador

J. Jess Acosta Elas 7

J. Jess Acosta Elas 8

En el men Progammer del mplab se da click en la opcin Select programmer(Ver figura

Figura 1.3: Esta imagen muestra como seleccionar al ICD2 en el mplab

Explicacin del programa

En la lnea 5 comienza la configuracin del microcontrolador

J. Jess Acosta Elas 10

La funcin FGS() Habilita deshabilita la proteccin de cdigo. Si se habilita no se puede

En la lnea 16 comienza el programa principal.

Con esto termina la prctica 1.

J. Jess Acosta Elas 11

Practica 2, los puertos de entrada/salida

Armado del sistema (ver la figura 1.1)

J. Jess Acosta Elas 12

El algoritmo: Si presionamos el push-button, se prende el led, si lo liberamos, se apaga el led.

//************* BITS de configuracion ********************

int main(void); //Prototipo funcion main

J. Jess Acosta Elas 13

Proyecto 1.1: Mostrar un nmero en un display de 7 segmentos. Este nmero es el ndice

Proyecto 1.3: Decodificar un teclado matricial de 4*4 y mostrar el nmero en un display

J. Jess Acosta Elas 14

Prctica 3, el problema del Read Modify Write

Algoritmo: Si se presiona el push-button, se prenden los leds, si se libera, se apagan.

//************* BITS de configuracion ********************

int main(void); //Prototipo funcion main

TRISB = 0b0000100000000000; //Todas salidas, solo RB11 entrada

J. Jess Acosta Elas 15

El siguiente programa es la forma correcta de resolver el algoritmo propuesto en la prctica.

int main(void); //Prototipo funcion main

//************** Programa principal **********************

TRISB = 0b0000100000000000; //Todas salidas, solo RB11 entrada

J. Jess Acosta Elas 16

J. Jess Acosta Elas 17

Prctica 4, el temporizador (Timer)

Primero revisamos unos sencillos conceptos:

Fosc = Frecuencia de oscilacin. Por ejemplo si usamos un cristal de 4 mhz y un

Tfosc = Periodo de oscilacin. Tfosc = 1/Fosc = 1/64000,000 = 0.000,000,015,625 seg =

Ahora como ejemplo calcularemos un retardo de 120 ms.

x = (62500*120)/1000 = 7500 = 0x1D4C

Esto significa que si el timer realiza 7500 cuentas en 120 ms.

J. Jess Acosta Elas 18

//************* BITS de configuracion ********************

//* BITS de configuracin ********

// Programa principal ********

//* BITS de configuracion ********

//* BITS de configuracion ********

// Programa principal ********

//* BITS de configuracion ********

// Programa principal ********