Pikit3 parte i-
-
Upload
gerardo-garcia -
Category
Documents
-
view
671 -
download
0
description
Transcript of Pikit3 parte i-
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 SFREstos 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 extendido18f45k20_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 (RD6RD0). 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 internopor 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 eneste 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 VoltagePrograming 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 inicializadasunsigned char LED_Number; // 8bit 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; // 8bit 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 07 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; // 8bit 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.RB0Esto 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; // 8bit 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; // AN812 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 pullup habilitadas ya que puede provocar fallos de lectura si no se presiona dicho switch sin habilitar pullup 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 pullup que en este caso es RBPU y lo ponemos a cero.WPUBbits.WPUB0 = 1; Habilitamos aquí, el pullup del RB0ANSELH = 0x00; Forzamos a que las entradas analógicas AN812 sean digitales poniéndolas a 0. TRISBbits.TRISB0 = 1; Configuramos RB0 como entrada.
Observa los registros AN812. 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 0123 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 0255 si se configura como 8 bits o, de 065535 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; // 8bit 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; // AN812 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 ifelse { // 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 DEBUGGERTenemos 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 seleccionadolas 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 ).