Está en la página 1de 17

Guía de pickit 3

 
           
 El contador de programa
   

Este tiene 21 bits de anchura y se divide en tres de 8 bits, PCL, PCH, PCU siendo PCH Y 
PCU los registros a los que no se puede escribir directamente ni tampoco son visibles a no ser que 
se realice mediante alguna instrucción de lectura o escritura sobre el registro PCL. De esta forma se 
actualiza los registros superiores del PC. También es modificable si una instrucción de salto o de 
subrutina se ejecuta, permitiéndose la escritura directamente por dichas instrucciones pero el dato 
no será transferido desde el PCH y PCU  al contador de registro.
Ante un reset, el  PC se carga con el valor 0, por lo que este apunta a la dirección 0 de la 
memoria de programa, y según la instrucción escrita (normalmente un "goto") así actuará.
Hay que decir que las instrucciones no se pueden ejecutar en bytes impares, ya que el 
   PC
    
solo va saltando de dos en dos ya que su bit de menos peso, tiene siempre puesto a 0 por lo que solo  
son pares las lineas a las que salta.

   PROGRAMANDO CON C
              

El compilador C para pic de MPLAB implementa la siguiente regla:
1. Las instrucciones se almacenan en la sección denominada “code.”
2. Los datos son almacenados en “romdata” conjuntamente con “ROM”

MPLAB  C  COMPILER  puede   generar  dos  modelos   de  memoria,   corto    y  largo.  En   el 
modelo corto se usa un puntero de 16 bits, mientras que el modelo largo se usa uno de 24 bits (PC).

 
           
 MEMORIA
      DE    DATOS 

La   memoria   de   datos   es   llamada   “file  register”   o   memoria   de   registros.   Una   vez   que 
encendemos el pic, los datos contenidos en dichos registros, son aleatorios. Los registros se agrupan 
en orden de 256 bytes los cuales pueden ser seleccionados en bancos accesibles por los 4 bits de 
mayor peso del registro de direcciones  BSR  (  Bank  Select  Register  ). Las áreas especiales en el 
banco 0 y en el 15 son directamente accesibles y son denominadas ACCESS RAM y es aquí donde 
están los registros especiales (FSR) como son por ejemplo, los registros para programar un puerto 
de I/O, bits de algún registro de estado....

#pragma varlocate le dice al compilador dónde se almacenan las variables.

Las  variables  no inicializadas son almacenadas en memoria mediante “udata”, y el compilador 


realizará   lo   necesario   para   almacenar   y   distribuir   los   datos   correctos,   así   como   su   tipo   para 
optimizar la memoria al máximo, una vez que lo inicialice el compilador pasará los datos de la 
memoria de programa a la de datos para comprobar su correcta ortografía y tipos de datos para 
luego optimizar el programa.

REGISTROS ESPECIALES SFR
Estos   registros   especiales  son (  PC, status, pila,  EEDATA,,,,) sirven para  programar   los 
periféricos y los demás registros como STATUS o PC   y el compilador de C puede acceder a ello 
por su nombre y puede modificarlos y leerlos como si fuesen variables. Se localizan el el Banco 15 
de la memoria de datos.
EJERCICIOS PRACTICOS SOBRE C

EJERCICIO 1

Conectar el PICKIT3 al puerto usb del pc y después conectarnos la placa al conector ICSP.
Vamos a crear un proyecto de compilación en C con el  compilador C de MPLAB.
El proyecto consiste en encender un led indefinidamente conectado a una puerta, y veremos 
como se realizan todos los pasos para su compilación. Para crear un proyecto vamos a realizarlo 
mediante el asistente, por lo que accedemos a Project>Project Wizard... y nos sale una ventana de 
bienvenida, por lo que pulsamos NEXT.
1. Seleccionamos un componente que en este caso será PIC18F45K20 y pulamos en Next.
2. Seleccionamos el lenguaje de programación “Microchip C18 Toolsuite”  y pulsamos Next.
3. Crear   un   nuevo   proyecto.   Busca   C.\Lessosn\PICKIT  3  Debug  Express  Lessons\01  Hello 
LED  y nombra el proyecto  Lessson1  LED  y lo guardamos con  SAVE  entonces le damos a 
NEXT para continuar.
4. Podemos añadir archivos y fuentes que tengamos escritos al proyecto ( evidentemente  antes 
deben estar creados en nuestro disco duro) . A la izquierda seleccionamos el archivo  01 
HELLO LED.c  y lo añadimos. Pulsamos Next para continuar.
5. Esta ultima ventana verificaremos todos nuestros datos y pincharemos en Finish.

Para ver el proyecto que hemos creado, vamos a   View>Project y veremos nuestro área de 
trabajo el archivo llamado  Lesson 1 LED.mcw( en el título de la ventana) y el archivo proyecto 
Lesson 1 LED.mcp .
Para   completar   el   proyecto   tenemos   que   añadir  Linker   Script  y   el  header  del 
microcontrolador al proyecto. El Linker Script se necesita para construir el proyecto. Es un archivo 
de comandos para el compilador y se definen las opciones que describe el mapa de memoria del 
microcontrolador y existen 4 linkers:
18f45k20.lkr   Linker básico en modo no extendido
18f45k20_e.lkr Linker para compilar en modo extendido.
18F45k20i.lkr Linker que se usa con Debbuger ( previene  el código de aplicaciones
ejecutar pequeñas áreas de memoria reservada al debugger.).
 18f45k20i_e.lkr Linker para el debbuger en modo extendido.
Para añadir el linker al proyecto hacemos Project>Add files to project... y dentro de la caja 
de selección de “Files of types”   seleccionamos   Linker Scritp (*.lkr) que están en C\MCC18\h y 
abrimos el  p18f45k20.h. Una nota importante, si modificamos el archivo seleccionado en nuestro 
proyecto, también se modificará el original y por tanto eso no lo deseamos, por lo que haremos lo 
siguiente,  File>Save   AS....   para   salvar   una   copia   en   el   nuevo   proyecto,   es   decir,   el   archivo 
p18f45k20.h    lo   copiaremos   en   el   presente   proyecto   y   así   no   lo   modificaremos.   Por   último 
File>Save Workspace. Debe quedarnos algo así:

El programa :
/**  C   O  N   F  I G U  R   A  T  I  O  N      B  I  T  S  ******************************/ 
#pragma config FOSC = INTIO67 
#pragma config WDTEN = OFF, LVP = OFF 

/** I N C L U D E S   **************************************************/ 
#include "p18f45K20.h" 

/**  D   E  C   L  A R A  T   I  O  N  S  *******************************************/ 

void   main   (void) 

        TRISD = 0b01111111; //    PORTD bit 7 to output (0); bits 6:0 are inputs  (1) 
        LATDbits.LATD7 = 1; //    Set LAT register bit 7 to turn on LED 
        while (1) ; 

Veamos como funciona esto,,,,
#pragma config   Sirve para configurar los registros, que en este caso son FOSC Y WDTEN Y LVP
#include      Para incluir los header de los chips usados

TRISD Es una variable que accede al sfr con el mismo nombre TRISD que está incluida en 
el include anterior. En concreto esta pone a 0 o 1 los bits de la puerta D siendo 0 las 
que se usan como salida y 1 los que se usan como entrada. Así  tenemos el código 
0b01111111 por lo que pone a RD7 COMO SALIDA Y EL RESTO COMO 
ENTRADA (RD6­RD0). El “0b” es una notación para el compilador que le indica 
que el dato expresado es “binario”, si fuese hexadecimal seria 0x.....

LATDBITS.LATD7   LATDBITS  también está definido en el p18f45k20.h y permite el acceso  a los 
bits individuales del registro LATD el cual en esta instrucción se pone a 1 la salida 
D7 a través de LATD7 ( latch7).

CONSTRUYENDO Y PROGRAMANDO EL PROYECTO

Seleccionamos  Project> Build All. El archivo generado es un hex que se grabará en el pic.
Cuando   termine   aparece   el   mensaje  Build  sucess,   si   ha   ocurrido   algún   error,   del   tipo 
p18f45k20.h no se a podido encontrar, es debido a que MPLAB C fue instalado sin añadir  Add 
header file path to MCC_INCLUDE enviromnet variable option   durante la instalación por lo que 
habrá que reinstalar  MPLAB C  de nuevo.
Ahora   vamos   a   elegir   el   pickitt   3   como   programador   yendo   a  Programmer  >   Select 
Programmer > 4pickitt 3. lo que hará que aparezca una nueva pestaña en la parte de la ventana de 
información, mostrando el estado de dicho programador y todos los mensajes que se produzcan. El 
programador será inicializado y éste debe informar de que ha encontrado la placa DEMO a la que 
está enganchado y mostrar el microcontrolador que posee, que en este caso es nuestro pic18f45k20.
Aquí podemos observar que  no se ha detectado  
la placa con el pic ya que sino se programa al  
pikit3   para   que   alimente   a   la   placa,   esta   no  
podrá ser encontrada de ninguna manera.
Para   ello   debemos   de   configurar   el   pickit   3 
para ello y por tanto   vamos a Programmer > 
Settings...
Para   dicho   pic   debemos   alimentarlo   como  
máximo a 3,25 volts y por tanto deslizaremos el  
cursor   hasta   que   esté   en   dicha   tensión.   Lo  
salvamos   dando   ok   y   debe   aparecer   en   la  
ventana nuestro pic18f45k20.
Pasamos ahora a meter el programa en el pic18f45k20 yendo a  Programmer > Program  y 
…. listo, ya esta programado. Si se ha cometido algún error en la programación consultar la ayuda 
del pickit 3  Help> Topics...  y bajo  Programmer  seleccionamos  pickit 3  y OK. En la pestaña de 
contenidos seleccionamos Troubleshooting para más información.

PROYECTO 2 LED PARPADEANTE.

Aquí se expone un proyecto con la meta de:
– Abrir un área de trabajo de proyecto seleccionado desde File>open Workspaces
– Configuración   de   bits   de   propósito   especial,   modos   de   operación   y   habilitar 
características del microcontrolador.
– Retardos, librerías.....

En este punto, ya hemos programado nuestro pic18f45k20 y todavía no se ha cerrado el 
proyecto, pero nosotros vamos a abrir otro área de trabajo para el nuevo proyecto. Para ello debemos 
ira File >Open Workspaces.... y buscamos C:\Lessons\PICkit 3 Debug Express Lessons\02 
Blink LED y abrimos el 02 Blink LED.mcw archivo.
Antes de abrir una nueva área de trabajo, MPLAB nos pregunta si queremos guardar la 
anterior, por lo que lo recomendable es decir que si.

CONFIGURANDO BITS 

En este ejercicio, la configuración de los bits están definidas  en la parte superior del archivo 
de Blink LED. C como se muestra:

/**  C  O N  F I G  U  R  AT   I O   N     B I  T  S  ******************************/ 
#pragma   config FOSC=INTIO67, FCMEN=OFF,  IESO = OFF          // CONFIG1H 
#pragma   config PWRT = OFF,    BOREN= SBORDIS, BORV = 30     // CONFIG2L 
#pragma   config WDTEN     = OFF, WDTPS = 32768                          // CONFIG2H 
#pragma   config MCLRE = OFF, LPT1OSC = OFF, PBADEN = ON, CCP2MX = PORTC       
// CONFIG3H 
#pragma   config STVREN= ON, LVP = OFF, XINST = OFF               // CONFIG4L 
#pragma   config CP0 =OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF  // CONFIG5L 
#pragma   config CPB = OFF, CPD = OFF                                         // CONFIG5H 
#pragma   config WRT0 = OFF,    WRT1 = OFF, WRT2 = OFF, WRT3 = OFF        // CONFIG6L 
#pragma   config WRTB = OFF,    WRTC = OFF, WRTD = OFF                             // CONFIG6H 
#pragma   config EBTR0 =OFF, EBTR1 = OFF, EBTR2 = OFF, EBTR3 = OFF    // CONFIG7L 
#pragma   config EBTRB = OFF                                                          // CONFIG7H 

Como vimos en el ejercicio anterior, los bits se configuran utilizando  #pargma config  y 
separándolos por   comas. Cada microcontrolador tiene sus propias características y las podemos 
encontrar en MPLAB IDE HELP. Por ejemplo vamos a buscar las del pic18f45k20:
1 Seleccionarnos MPLAB IDE menú Help>Topics... y buscar la categoría Lenguajes 
Tool.
2 PIC18 Config Settings” luego OK.
3 Cuando la ventana de ayuda se abra, seleccionamos la pestaña Contenidos y expandir 
la sección “ Configuration Settings” .
4 Seleccionamos nuestro pic18f45k20.

La configuración de los bits en este ejercicio es diferente a la que trae por defecto, por lo que 
vamos a prestar atención y vemos como funciona.

FOSC = INTIO67 Esta configuración configura al pic para que trabaje con el oscilador interno
por lo que no necesita ningún oscilador de cristal externo para funcionar.
La frecuencia por defecto es de 1 MHz y así podemos utilizar los pines RA6
(osc1) y RA7 (osc2) como bits de I/O de la puerta A ya que no se van a usar 
como entradas para el oscilador.
WDTEN = OFF Esta configuración nos permite apagar el Watchdog Timer ( WDT) ya que en
este ejercicio no lo vamos a usar. Ya se sabe que si usamos el WDT y no lo 
refrescamos, éste reseteará el microcontrolador.
 LVP = OFF                
   Esto apaga el modo de Low Voltage­Programing  y por tanto libera la patita
    
 
                                   
 PGM o RB5 ya que LVP no lo usa PICKIT 3.
   

El resto de los bits son iguales a los que trae por defecto, pero no está mal recordarle al 
compilador de que es ésta y no otra la configuración que nosotros deseamos.
Y ahora ponemos el programa principal. Observa que la linea # include ha añadido un nuevo 
fichero y también el símbolo “ ~ “ delante del LATDbits.LATD7

/** I N C L U D E S   **************************************************/ 
#include "p18f45k20.h" 
#include "delays.h" 

/**  D    E C   L   A  R  A  T   I   O  N  S   *******************************************/ 

void   main   (void) 

        TRISD   =   0b01111111;//    PORTD   bit    7   to   output   (0)   ;  bits   6:0  are   inputs (1) 
        while   (1) 
        { 
                  LATDbits.LATD7   =   ~LATDbits.LATD7;       //   toggle   LATD 
                  Delay1KTCYx(50);//    Delay    50   x    1000  =   50,000   cycles;   200ms  @   1MHz 
        } 

                                          
Observa que se ha incluido la linea #include “delays.h” , este header se localiza al igual que 
p18f45k20.h , osea de C:\MCC18\h. Y por tanto , tenemos la instrucción de esta librería utilizada en 
el programa con la línea Delay1KTCYx (50) ;
Esta   función   crea  un retardo de  1000  instrucciones  de  ciclo  multiplicado  por  lo  que hay  entre 
paréntesis y nos daría 1000*50= 50.000 ciclos y como en nuestro microcontrolador el ciclo es ¼ de 
la señal de reloj, pues en este caso ( sin oscilador es 1MHzz) será 1mHz/4 = 250KHzz lo que nos da 
unos 200 ms que mas que suficiente lento para que nuestro ojo lo vea parpadear.

LESSON 3 ROTACION LED

Este programa realiza el desplazamiento de leds encendiendo uno detrás de otro. El archivo 
03 Rotate LED.c declara una variable como global llamada LED_Number y así se asigna:

/** V A R I A B L E S *************************************************/ 
#pragma udata  // asigna variables estáticas no inicializadas
unsigned char LED_Number;  // 8­bit variable 

La directiva #pragma udata sirve para decir al compilador que las variables de datos que a 
continuación siguen, se deben de meter en los registros del PIC( ojo es en el área de registros).
Hay dos directiva que se pueden usar con #pragma
– udata : Se almacenan datos (registros) sin inicializar en los registros del pic.
– idata: Los datos inicializados se almacenan en el espacio de registros del pic y los datos 
de la inicialización son guardados en la memoria de programa y movidos por el código 
de inicialización de arranque, antes de que empiece el programa.

La declaración de datos puede pertenecer a una sección con un nombre. Dicho nombre de 
sección puede asociarse a un script SECTION para colocarlo en un área particular de memoria.
La directiva #pragma udata se debe de especificar la dirección de comienzo de los datos a 
almacenar en el pic y a partir de estas, serán secuenciales una detrás de otra. Supongamos que 
queremos colocar la variable LED NUMBER al inicio del banco de registros número 3, y por tanto 
se debería de programar así:
#pragma udata mysection = 0x300 unsigned char 
LED_Number;  // 8­bit variable unsigned int 
AnotherVariable; 

Aquí mysection es una sección con dicho nombre y que empieza en la dirección 0x300 y los 
datos que va a recibir serán del tipo unsigned char. LED Number será una variable y separada por ; 
las siguientes variables. Hay que decir que no es lo mismo guardar datos de 8 bits que de 16 como 
por ejemplo el tipo de dato integer que es de 16 bits lo que ocupará dos posiciones  en la sección.

Hasta ahora hemos visto como se insertan datos en el área de registros, y a continuación 
veremos como metemos datos en el área de programa.

/** D E C L A R A T I O N S *******************************************/ 
// declare constant data in program memory starting at address 0x180 

#pragma romdata Lesson3_Table = 0x180 
const   rom  unsigned   char   LED_LookupTable[8]   =   {0x01,   0x02,   0x04,   0x08,   0x10,   0x20,   0x40,  
0x80}; 
#pragma  code //  declare executable instructions 
void  main  (void) 

…..

Podemos ver dos directivas usadas:
code : Las propias instrucciones del programa. Compilará las instrucciones del programa en 
la memoria de programa del pic.
     Romdata : Datos almacenados en la memoria de programa. Se suele usar con la directiva 
“rom” y los datos serán del tipo constante ( no pueden variar) y compilados en 
espacio de memoria de programa.
En este ejercicio se va a utilizar un array de datos LED_LookupTable para convertir un 
número representando los leds 0­7 en un patrón de bits para configurar apropiadamente el puerto D 
que   se   denomina   PORTD   para   poder   encender   un   led   tras   otro.   Por   eso   se   utiliza   un   array 
constante , para que los datos de dicho array no cambien por culpa del programa o acción indebida. 
Por lo tanto, esta constante es declarada en romdata sección y usa “rom” para hacerla constante y 
colocarla en la parte de la memoria de programa. 
La sección romdata ha sido declarada también con un nombre Lesson3_Table y asignada a 
una dirección 0X180.
Selecciona MPLAB IDE Project> Build All para compilar el ejercicio y después selecciona 
View> Program Memory para visualizar el contenido compilado de la memoria de programa.

Observar como el la dirección 0180 está el array ( está invertido por el sistema de programación) se 
puede observar  0201 ( invertido será 01/02) y el 0804 (04/08).... 

Si colocamos #pragma code y a continuación colocamos main() , el programa se almacenará 
en la sección indicada en la memoria de programa del pic. Si no se ha especificado ninguna sección 
ni tampoco la dirección de inicio de programa, el compilador colocará el programa en la siguiente 
sección de programa libre que tenga el pic.

El programa:

/** V A R I A B L E S *************************************************/ 

#pragma udata  // declare statically allocated uninitialized variables 
unsigned char LED_Number;  // 8­bit variable 
/** D E C L A R A T I O N S *******************************************/ 
// declare constant data in program memory starting at address 0x180 

#pragma romdata Lesson3_Table = 0x180 
const   rom   unsigned   char   LED_LookupTable[8]   =   {0x01,   0x02,   0x04,   0x08,   0x10,   0x20,   0x40,  
0x80}; 
#pragma   code //   declare   executable   instructions 

void main (void) 

   LED_Number = 0; //       initialize 
   TRISD   =   0b00000000; //   PORTD   bits  7:0    are   all   outputs   (0) 
   while   (1) 
   { 
             // use lookup table to output one LED on based on LED_Number value 
        
        LATD = LED_LookupTable[LED_Number]; 
        LED_Number++; //    rotate   display  by   1 
        if (LED_Number == 8) 
        LED_Number = 0; //      go   back  to  LED    0. 
        Delay1KTCYx(50); //    Delay   50  x  1000    =   50,000   cycles;   200ms @ 1MHz 
   } 
}

Inicialización de variables y I/O puertos.
Se  configura  trisd  para que todas  las patitas  del  portd  sean salidas y la variable global 
LED_Number es el numero de led a encender.
Primero se inicializa con el valor 0 en  LED_Number  y después se usa como array   en el 
índice y el array devuelve el valor por la posición que le indica LED_Number. Como el valor inicial 
de LED_Number es cero, el índice del array es cero también, por lo que su valor a devolver es el 
primer dato del array, osea 0x01. Este valor es almacenado en el latch del puerto D quedando en 
primera instancia la formula con el siguiente valor:

LATD =LED_lookupTable[LED_Number] siendo su valor LATD = 0x01

Seguimos y vemos que ahora se incrementa  LED_Number  por lo que el próximo valor a 


mostrar será el siguiente (0x02). Se compara el valor del índice( LED_Number) por si su valor es 8, 
que en caso de afirmativo volvería a poner a LED_Number a 0 ( reset) o en caso contrario ejecuta un 
retardo de 200 ms y vuelve de nuevo al array indefinidamente haciendo girar los leds.

Ejercicio 4 Rota switch

En este ejercicio se utiliza un switch para hacer rotar los leds del ejercicio anterior.
Se utiliza la directiva #define y se asume que el lector ya sabe o por lo menos está  familiarizado 
con el lenguaje C. 
#define Pin_Switch  PORTBbits.RB0
Esto hará que cada vez que pongamos Pin_Switch el compilador lo sustituye  por PORTBbits.RB0.
Pero para que el compilador entienda la directiva #define  se debe incluir el archivo cabecera “04 
Switch Input.h”, veamos como:
#include “04 Switch Input.h”
Existe un programa en aplicaciones que usan los switch que evitan el efecto rebote. Es un 
efecto que al pulsar el switch, rebota los contactos haciendo de una pulsación simple , en un tren de 
pulsos que provocaría efectos indeseados. Supongamos que queremos contar las veces que pulsamos 
en el switch, este al ser pulsado una vez podemos encontrarnos con la sorpresa que nuestro contador 
pueda contar 10 100 o 3 unidades en vez de una , que es la que esperábamos.
Para evitar este efecto rebote, se añade un retardo de 5 ms , tiempo mas que suficiente para 
que la señal sea estable y eliminaremos dicho efecto. 

Este es el organigrama para evitar dicho efecto. Observa que espera a que se pulse el switch, 
cuando este es presionado, se incrementa un contador y cuando este llega a 5 entonces da la señal de 
que se ha pulsado dicho switch. En caso de que el contador no haya llegado a 5  se realiza un retardo 
de 1 ms y se vuelve a incrementar el contador haciéndose la misma pregunta una y otra vez hasta 
que se completen los 5 ms que será cuando el circuito realice el organigrama unas 5 veces y cada 
una de ellas de 1 ms.
El programa:

/** V A R I A B L E S *************************************************/ 

#pragma udata  // declare statically allocated uinitialized variables 
unsigned char LED_Display;  // 8­bit variable 

/** D E C L A R A T I O N S *******************************************/ 
#pragma code //     declare   executable  instructions 
void  main   (void) 

        unsigned    char   Switch_Count  =  0; 
        LED_Display    =   1;               //   initializa 
        TRISD   =   0b00000000;             //   PORTD   bits  7:0   todas salidas    (0) 
        INTCON2bits.RBPU = 0;               //   habilita PORTB internal pullups resistencias
        WPUBbits.WPUB0 = 1;                 //   enable pull up on RB0 
        ANSELH = 0x00;                      //   AN8­12 are digital inputs (AN12 on RB0) 
        TRISBbits.TRISB0 = 1;               //   PORTB bit 0 (connected to switch) is input       (1) 
        while (1) 
        { 
            LATD = LED_Display;             //   enciende el led
            LED_Display <<=      1;         //   rotate   display by     1 
           if (LED_Display == 0)            //   rotated   bit  out,   so   set  bit   0 
                LED_Display = 1; 
            while   (Switch_Pin   !=  1); //   wait  for   switch  to    be  released 
            Switch_Count = 5; 
            do 
            { // monitor switch input for 5 lows in a row to debounce if 
                  (Switch_Pin == 0) 
                  { // pressed state detected 
                       Switch_Count++; 
                  } 
                  else 
                  { 
                     Switch_Count = 0; 
                  } 
                  Delay10TCYx(25);  // delay 250 cycles or 1ms. } 
             while (Switch_Count < DetectsInARow); 

Ojo a las variables, ya que la variable global se almacena en un registro del pic mientras que 
las variables locales se destruyen al salir de la función que la crea. Así   LED_Display es global 
mientras que Switch_Count es local y se destruye al finalizar el programa ya que se almacena en la 
pila del programa.
El interruptor está conectado a RB0 y cuando este es pulsado se tira a masa “0” por lo que 
debe estar con resistencias pull­up habilitadas  ya que puede provocar fallos de lectura si no se 
presiona   dicho   switch   sin   habilitar   pull­up   del   RB0.   Pero   esta   patita   comparte   con   la   entrada 
analógica AN12, es decir, que el mismo pin puede ser digital o analógico. Hay que configurarlo 
como digital y como entrada.Para ello vemos como lo hace en el programa:

INTCON2bits.RBPU   =   0;    aquí   podemos   ver   como   configurar   el   registro   INTCON2   el   bit 
correspondiente al pull­up que en este caso es RBPU y lo ponemos a cero.
WPUBbits.WPUB0 = 1;      Habilitamos aquí, el pull­up del RB0
ANSELH = 0x00;    Forzamos a que las entradas analógicas AN8­12 sean digitales poniéndolas a 0.
 TRISBbits.TRISB0 = 1;     Configuramos RB0 como entrada.

Observa los registros AN8­12. Aquí se usa un sistema de rotado de leds mas simple que en el 
ejercicio anterior el cual usaba una tabla con un índice para poder mostrar un patrón de bits en la 
salida y aparentar el desplazamiento. En este caso usaremos algo mucho mas sencillo para realizar 
el mismo efecto, en este caso se desplaza el bit de mayor peso de LED_Display y como es mostrado 
en LATD pues se muestra en la salida.
 LED_Display <<=      1;

Ejercicio 5 Temporizador

En   este   ejercicio   vamos   a   utilizar   el   temporizador   TMR0   en   vez   de   utilizar   un   bucle 


temporizado, dejando así  libre a la CPU de dicho conteo, encargándose de la cuenta el TMR0.
Veamos sus registro de configuración:

• El bit 7 activa o no el temporizador.
• El bit 6 se usa para seleccionar entre 8/16 bits.
• El bit 5 selecciona entre entrada externa o ciclos de reloj interno.
• El bit 4 se usa para activar la cuenta en el flaco de subida de la señal o la de bajada.
• El bit 0­1­2­3 se usan para activar el preescaler (divisor) y su rango de división.

El TMR0 es el temporizador/contador de la familia 18Fxxxxx que utiliza el reloj interno o 
los impulsos externos a través de la patita TOCK1. Puede realizar cuentas de 0­255 si se configura 
como   8   bits   o,   de   0­65535   si   lo   hace   en   modo   16   bits.   Un   bit   de   flag   se   activa   cuando   el 
temporizador ha llegado a rebasar la cuenta y vuelve de nuevo a cero.
El   preescaler   se   usa   para   generar   una   cuenta   por   cada   impulso   del   reloj   de   entrada 
( recordemos que la frecuencia interna es ¼ la frecuencia del oscilador ) y si el rango del preescaler 
es de 1/8  significa que dará un pulso por cada 8 pulsos de reloj, si es 1/16 pues cada 16......
El   preescaler   se   borra   cuando   se   escribe   en   el   temporizador,   por   lo   que   habrá   que 
configurarlo cada vez que se escriba en el temporizador.
Cuando utilicemos el temporizador en modo 16 bits, hay que prestar especial atención ya que 
se usan el temporizador bajo y el alto TMR0L y TMR0H ubicados en la zona de registros SFR del 
pic y que TMR0L es leíble y se escribe   directamente, mientras que la parte alta del contador 
TMR0H no es directamente accesible. En su lugar se usa TMR0H pero para poder leerlo, primero 
debemos LEER EL TMR0 PRIMERO Y DESPUES SE ACTIVARÁ TMR0H Y PARA ESCRIBIR 
EN EL TEMPORIZADOR PRIMERO SE ESCRIBIRÁ EN TMR0H ANTES QUE TMR0L.
En el ejercicio vamos a temporizar entre 200 y 300 ms y vamos a ver como hacemos esto a 
través de nuestro preescaler.
Hay que configurar T0CON para que el resultado sea satisfactorio y por ello en la tabla 
anterior vemos como se configuran los bits de dicho registro.

– Lo ponemos en modo 16 bits por lo que el bit 6 lo ponemos a 0.
– Usaremos los ciclos internos de reloj por lo que el bit 5 se queda a 0.
– Como la temporización coincide con el tiempo que queramos no usaremos el bit PSA o 
bit   numero   3   ya   que   65536   x   (1   /   250,000)   =   262ms,   es   decir,   si   la   cuenta   del 
temporizador llega a 65536 y tarda en cada ciclo  1/250,000 pues nos da los 262 ms que 
está dentro de nuestro rango.
– El bit 7 se pone a 0 ya que queda desactivado y se activa cada vez que se escribe en el.

El resto de bits no importa su configuración por lo que el dato a escribir de forma binaria en 
el T0CON será 0b0000100.
Abrir el archivo 05 Timer.c y 05 Timer.h. En el archivo de cabecera .h podemos encontrar 
las siguientes sentencias:
typedef enum { LEFT2RIGHT, RIGHT2LEFT}  LEDDirections; 
typedef enum {FALSE, TRUE} BOOL; 

El tipo de dato enum, utiliza un nombre LEDDirections para identificarlos y solo admite los 
valores que están entre paréntesis, que en este caso es  LEFT2RIGHT, RIGHT2LEFT, es decir, que 
si utilizamos la variable LEDDirectios, sus valores que puede tomar son estos dos y no otros.
Quizás le sea más fácil la linea del enum BOOL que le hemos puesto que solo admita como 
valores FALSE Y TRUE.
Hay que inicializarlas como cualquier variable pero, solo con los valores que admite. Ojo 
son tipos de variables no variables en si ( como lo son integer, char, double....). Veamos como se 
inicializan:

LEDDirections Direction = LEFT2RIGHT; 
BOOL SwitchPressed = FALSE; 

Aquí podemos ver que hemos definido una variable Direction del tipo LEDDirections y con 
el valor inicial LEFT2RIGHT ( que es el valor que definimos en el tipo enum). Así Direction solo 
puede tener dos valores LEFT2RIGHT Y RIGHT2LEFT únicamente.
Para el tipo BOOL hemos definido otra variable llamada SwitchPressed y se ha inicializado 
con el valor FALSE.
La variable Direction será utilizada para determinar la dirección de rotación de los leds y la 
variable Switchpressed recuerda al programa que se ha presionado el switch el cual cambiará el 
sentido de la rotación de los leds.

//  Inicializamos el contador 
INTCONbits.TMR0IF   =  0;  //  line  1 
T0CON = 0b00001000;        //  line  2 

// T0CON  =  0b00000001;  (se ignora por el momento) 
TMR0H = 0;                 //  line  3 
TMR0L = 0;                 //  line  4 
T0CONbits.TMR0ON  =   1;   //  line  5 

Esta es la parte del programa que inicializa el temporizador , deshabilita las interrupciones 
generada por el mismo al sobrepasar la cuenta, escribe en el registro T0CON el patrón de bits a 
configurar para la temporización, así como la escritura en el temporizador en el orden preferente 
siendo TMR0H la primera en escribirse y luego TMRL0 la última, y por último habilitamos el 
temporizador.

El programa:

// ******************************************************************* 
// *    See included documentation for Lesson instructions           * 
// ******************************************************************* 
/** C O N F I G U R A T I O N   B I T S ******************************/ 

#pragma config FOSC = INTIO67, FCMEN = OFF, IESO = OFF                      // CONFIG1H 
#pragma config PWRT = OFF, BOREN = OFF, BORV = 30                           // CONFIG2L 
#pragma config WDTEN = OFF, WDTPS = 32768                                   // CONFIG2H 
#pragma config MCLRE = ON, LPT1OSC = OFF, PBADEN = ON, CCP2MX = PORTC            //  
CONFIG3H 
#pragma config STVREN = ON, LVP = OFF, XINST = OFF                          // CONFIG4L 
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF                   // CONFIG5L 
#pragma config CPB = OFF, CPD = OFF                                         // CONFIG5H 
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF               // CONFIG6L 
#pragma config WRTB = OFF, WRTC = OFF, WRTD = OFF                           // CONFIG6H 
#pragma   config  EBTR0  = OFF,  EBTR1  =  OFF, EBTR2  =  OFF, EBTR3  = OFF                      //  
CONFIG7L 
#pragma config EBTRB = OFF                                                  // CONFIG7H 

/** I N C L U D E S **************************************************/ 
#include "p18f45k20.h" 
//#include "delays.h"  // no longer being used.
#include "05 Timer.h"  // header file 

/** V A R I A B L E S *************************************************/ 
#pragma udata    // declare statically allocated uinitialized variables 
unsigned char LED_Display;   // 8­bit variable 

/** D E C L A R A T I O N S *******************************************/ 
#pragma code     // declare executable instructions 
void main (void) 

    LEDDirections Direction = LEFT2RIGHT;  // es del tipo enum en el archivo .h
    BOOL SwitchPressed = FALSE;  // también del tipo enum en .h
   LED_Display = 1;            // initialize la variable global
    // Init I/O 
    TRISD = 0b00000000;      // PORTD bits 7:0 son todas salidas (0) 
    INTCON2bits.RBPU = 0; // enable PORTB internal pullups 
     WPUBbits.WPUB0 = 1; // enable pull up on RB0 
    ANSELH = 0x00;              // AN8­12 are digital inputs (AN12 on RB0) para convertir a digitales
    TRISBbits.TRISB0 = 1;       // PORTB bit 0 pone esta como entrada.

    // Init Timer 
    INTCONbits.TMR0IF = 0;          // se borra el flag de cuenta sobrepasada.
    T0CON = 0b00001000;             // Configuración del tocon sin preescaleer.
    //T0CON = 0b00000001;             // prescale 1:4 ­ four times the delay.
TMR0H = 0;                      // borrado del temporizador parte alta
    TMR0L = 0;  // parte baja
    T0CONbits.TMR0ON = 1;           // comienza a temporizar
    while (1) 
    { 
        if (Direction == LEFT2RIGHT) // recuerda que si inicializo con LEFT2RIGHT
        { 
            LED_Display <<= 1;          // rotate display by 1 from 0 to 7 
            if (LED_Display == 0) 
                LED_Display = 1;        // rotated bit out, so set bit 0 
        } 
        if (Direction == RIGHT2LEFT) 
        { 
            LED_Display >>= 1;          // rotate display by 1 from 7 to 0 
            if (LED_Display == 0) 
                LED_Display = 0x80;     // rotated bit out, so set bit 7 
        } 
        LATD = LED_Display;         // output LED_Display value to PORTD LEDs 
        do 
        { // comprueba si el pulsador esta pulsado
            if (Switch_Pin == 1) // recuerda el el pulsador se pone a masa cuando se pulsa
            { // el pulsador no esta pulsado
                SwitchPressed = FALSE; 
            } 
            else if (SwitchPressed == FALSE) // && (Switch_Pin == 0) due to if­else 
            { // el pulsador está presionado
                SwitchPressed = TRUE; 
                // cambia entonces la dirección
                if (Direction == LEFT2RIGHT) 
                    Direction = RIGHT2LEFT;  // aquí cambia la dirección escribiendo lo contrario.
                else 
                    Direction = LEFT2RIGHT; 
            } 
        } while (INTCONbits.TMR0IF == 0); // se repita el ciclo do while hasta TMR0 llegue a fin.

        // Timer expired 
        INTCONbits.TMR0IF = 0;          // Reset Timer flag 
    } 
}

EJERCICIO 6

EL DEBUGGER
Tenemos que decir, que el presente ejercicio, presenta por primera vez el uso del debugger 
usando   para   ello   el   programa   anterior.   Evidentemente   su   función   es   ver   en   tiempo   real   si   los 
registros   cambian,   que   valor   tienen   en   un   momento   determinado....   etc.   Esto   es   parecido   al 
simulador pero en este caso se reserva un área de memoria en el microcontrolador para efectuar el 
debugger o depurador de programa de forma que si el compilador hizo bien su trabajo, dejó este 
área vacía y reservada para este cometido.
El pickit3 se usará como ICD debuggin circuit y utilizará los recursos no accesibles para el 
usuario para dicho cometido en el pic.
En este caso la patita MCLR ( master control reset) está reservada para el cometido y por 
tanto no se podrá usar ni programar como entrada o salida I/O normal.
Los pines PGC Y PGD tampoco se usaran como puertos I/O ya que los usaremos en el 
debuggin.
Un área de la pila de memoria se usará y por tanto no accesible para el usuario.
Se utilizará un área de memoria de programa y de registros para el depurado y se queda 
marcado en el MPLAB IDE como una R (reservado) y por tanto, el usuario no podrá utilizar.
El pickit 3 no puede usarse como debugger ICD y programador al mismo tiempo, por tanto 
si se usa el debugger, el programador se desactiva.   Debugger > Select Tool > 2 PICkit 3 es lo que 
debemos de hacer para seleccionar el pikit3 como debugger.

Comenzamos:

1­ En la barra de herramientas del MPLAB IDE  seleccionamos Debug en vez de 
Release.
2­ Compilar el proyecto 05 ( esto reservará en el pic el área para su debuggin).
3­ Lo programamos Debugger> Program.
4­ Arrancamos el debuggin. Debugger > Run.

Se observa que el pic18f45k20 funciona con total normalidad, pero esta vez está en 
modo debuggin.
Operaciones básicas:
• HALT  El programa del pic18f45k20 se puede parar en cualquier momento, si pulsamos F5 
o vamos a Debugger > Halt . Se mostrará una flecha verde indicado el punto de parada.
• STEP Se permite ejecutar el program paso a paso de las siguientes maneras:
◦ STEP INTO se ejecuta paso a paso pero al llegar a una función de llamada se para y 
salta la primera linea de dicha función.
◦ STEP OVER se ejecuta paso a paso y al llegar a una función de llamada, esta se ejecuta 
entera y el salto llega al final de dicha funcion call.
◦ STEP OUT se ejecuta paso a paso y ejecuta sin parar las subrutinas.
• RUN se ejecuta el programa hasta encontrar un punto de break o sea parado por el usuario 
con HALT.
• RESET Se ejecuta Debugger > Processor> Reset Se ejecuta un reset del micro, pero solo si 
el   microcontrolador   estaba   previamente   parado   y   por   tanto   empieza   desde   la   primera 
instrucción de programa.
• RESET Se ejecuta con Reset>Processor Reset F6 Al ejecutarse MPLAB IDE abre un nuevo 
archivo c018i.c inicializa la pila de software C y asigna todos los datos de inicialización de 
variables permitiendo llevar al pic a un estado de judicialización completa y luego salta a la 
instrucción main() después de inicializar las variables.

Usando puntos de Parada.
La mejor forma de usar un punto de parada para que el programa al ejecutarse, se ejecute 
bien y se pare donde queramos, es ir a la linea que nos interesa y con el botón secundario del ratón 
pulsamos   y   ponemos   el   breakpoint   (   Set   breakpoint   ),   apareciendo   un   rombo   rojo   con   una   B 
indicando que ahí se parará el programa. Realicemos con la línea 111 o SwitchPressed = TRUE; y 
tal y como hemos puesto el punto de parada justo cuando se debe presionar el botón, el programa 
continua y por tanto no se para. Pero si se pulsa el botón, el programa quedará parado por el break 
que hemos colocado.

El número de breakpoints que se puede utilizar depende mucho del microcontrolador que se 
use, nuestro pic18f45k20 tiene 3 como máximo. Si abrimos  Debugger > Breakpoints podemos ver 
los break que se han usado y los máximos que permite nuestro pic ( HW BP )

Echando un vistazo a las variables y a los registros SFR.

Se pueden ver los registros abriendo View > File Registers  y los SFR con View > Special 
Function Registers , sin embargo no se recomienda que dichas ventanas estén abiertas ya que se 
pueden leer dichos registros desde la tarjeta cuando está en modo RUN parado o en modo paso a 
paso.   Leer   todos   estos   datos   sobre   el   ICD   BUS   puede   tomar   un   tiempo   significativo   debido 
principalmente a la memora que contenga el pic18f45k20 así como la velocidad de su reloj interno, 
así que es mejor cerrar las ventanas de los registros.
La mejor manera de ver los registros que sólo interesan es abriendo una ventana llamada 
Watch y se abre View > Watch

Los SFR que nos interese, 
lo   añadimos   desde   el   campo 
seleccionable que está marcado 
en   la   figura   de   arriba   como 
ADCON0 y pulsando el botón 
ADD   SFR   de   la   misma 
ventana.
Para   nuestro   ejercicio 
añadiremos PORTB Y LATD  ya que son los que hemos usado tanto para el pulsador como para la 
salida de los leds.
Las variables que hemos creado nosotros las podemos monitorizar  seleccionado­las desde el 
campo que  nos queda a la derecha ( que en este caso marca  config) y pulsando el botón  Add 
Symbol.
Añadiremos por tanto para nuestro ejercicio LED_Display, SwitchPressed y Direction. Y nos 
debe de quedar algo así:

Recordemos que nuestras variables del tipo “enum” como son  Direction y SwitchPressed se 
mostraran en este caso como valor numérico y no como palabras escritas (let2righ, right2left.... etc).
El formato de muestra de valores en el campo Value, se puede cambiar pinchando con el ratón y en 
Properties en el menú que nos aparece.
Con Watch podemos también cambiar los valores de las variables y por supuesto al cambiar dicho 
valor,   cambiará   en   realidad   en   el   pic18f45k20   y   por   tanto   si   escribimos   AA   en   el   LATD   se 
encenderán los leds correspondientes.
Selecciona ahora PORTB y selecciona sus propiedades y buscando el formato, lo cambiamos a 
binario, pulsamos OK y cerramos el dialogo. Ahora se verá la información de PORTB  en binario 
con el bit de mas peso a la izquierda(7).
Realizamos el paso a paso pulsando F8 ( step over )   que en este modo se ejecuta la subrutina y 
observa que el PORTB debe tener el switch ( PORTB0) a 1 ya que no se ha pulsado, claro que si 
pulsamos el botón y ejecutamos de nuevo con F8 el valor será 0 siempre que se mantenga pulsado 
hasta que sea ejecutada la subrutina. Recuerdas donde pusimos el punto de break....

Como podemos ver, el pulsador en estado normal es 1 por lo que la sentencia else if no se 
cumple y salta a el retos del programa por debajo de los corchetes.... Pero en caso de que si se 
cumpla, se parará al llegar a la linea 111 y deberemos pulsar o ejecutar paso a paso el programa, ya 
que se ha quedado en estado HALT. Pulsamos F8 para ver el registro PORTB0  como cambia a 0.
Practica con el código añadiendo los breakpoints donde te apetezca y observa los registro 
como   cambian.   Añade   también   TMR0L   y   TMR0H   a   la   ventana   WATCH   y   observa   su 
comportamiento,   sobre   todo   cuando   estamos   en   modo   paso   a   paso.   Comprobará   que   no   se 
incrementa por cada instrucción ya que cada instrucción compilada en C creará varias instrucciones 
en   lenguaje   ensamblador   y   el   Timer0   es   incrementado   una   vez   por   cada   instrucción   maquina 
ejecutada ( no C ).

También podría gustarte