Autor
Introducción al procesador PIC16F84A
Antes de nada, conozcamos como es la parte electrica del microchip, así se aprenderá mejor a programar...
Los puertos son entradas/salidas que permiten intercambiar bytes (pulsos) e información al microchip o del microchip al entorno, entre ellos se encuentran A y B
- El puerto A comprende en 5 pines, RA0, RA1, RA2, RA3 y RA4
Cada una puede recibir o emviar bytes, para ser procesados en el programa dentro del chip. - El puerto B en RB0, RB1, RB2, RB3, RB4, RB5, RB6 y RB7 que cumple la misma funcion que el puerto A.
- Cada una puede recibir o enviar bytes, para ser procesados en el programa dentro del chip.
- MCLR: Pin de reseteo del pic, cuando se pone a "0" el pic se resetea.
- Vdd y Vss: pines de alimentación (Vdd 5V y Vss a masa)
- OSC1/CLKIN y OSC2/CLKOUT: son para el oscilador Los tipos de osciladores mas usados son el XT (cristal de cuarzo) y el RC (resistencia y condensador) el modo de conexionado es el siguiente:
Oscilador XT
C1=C2=33pF
Crystal = 4MHz
Oscilador RC
C1 alrededor de 20pF
5K O = R1 = 100K O - Tipos de memoria
Los tres tipos de memorias son:
Primera: la memoria EEPROM donde almacenaremos nuestro programa que haremos, esta memoria solo podrá ser leida por el pic (el pic leerá las instrucciones del programa almacenado en esta memoria y las va ejecutando). Al apagar el pic esta memoria no se borra.
Segunda: la memoria RAM en cuyos registros se irán almacenando los valores de las variables que queramos y cuando nosotros queramos, por programa, al apagar el pic esta memoria se borra.
Tercera: la memoria EEPROM para datos, es un espacio de memoria EEPROM en la que se pueden guardar variables que queremos conservar aunque se apague el pic. Esta no se tratará por ser dificil de usar - La memoria EEPROM o memoria de programa
* El espacio marcado como "User memory Space" es el espacio de memoria donde irá nuestro programa, comprende las direcciones de memoria desde la 0000h hasta la 3FFh (3FFh en decimal es 1023, mas la dirección 0000h hacen 1024 direcciones, es decir, 1Kbyte)
* "Reset Vector" es la primera dirección a la que se dirige el pic al encenderlo o al resetearlo.
"PC" y los "Stack Level" son empleados por el pic y nosotros no tenemos acceso a ellos. - La memoria RAM
La memoria RAM no solo es usado para almacenar nuestras variables, también se almacenan una serie de registros que configuran y controlan el PIC.
Podemos observar que en la imagen que esta memoria esta dividida en dos bancos, el banco 0 y el 1, antes de acceder a un registro de esta memoria tenemos que preguntarnos en que banco estamos, generalmente se trabaja en el banco 0, ya veremos mas adelante como cambiamos de banco de memoria.
Fijándonos en el banco 1, las direcciones desde la 00h hasta la 0Bh están ocupadas por registros del pic, por lo que tendremos que empezar a guardar nuestras variables a partir de la dirección 0Ch.
Podremos acceder al resto de registros para cambiar la configuración o el estado del pic.
Faltaría añadir a este cuadro el registro mas utilizado de todos, el acumulador (W) o registro de trabajo. No se trata de un registro propiamente dicho ya que no tiene dirección pero se usa constantemente para mover datos y dar valore a las variables (registros). Por ejemplo, si queremos copiar la información del registro 0Ch en el registro 0Dh no podremos hacerlo directamente, deberemos usar una instrucción para cargar el valor del registro 0Ch en el acumulador y después otra instrucción para cargar el valor del acumulador en el registro 0Bh.
[/list]
ATENCIÓN: No continues a menos hayas entendido lo anterior
Ahora repasaremos un par de comandos de nuestro PIC:
Código:
ESTADO EQU 0x03
PORTA EQU 0x05
PORTB EQU 0x06
org 0
bsf ESTADO,5
clrf PORTA
comf PORTA,1
clrf PORTB
bcf ESTADO,5
INICIO btfsc PORTA,0
goto APAGAR
goto ENCENDER
APAGAR bcf PORTB,0
bsf PORTB,1
goto INICIO
ENCENDER bsf PORTB,0
bcf PORTB,1
goto INICIO
end
ORG: Indica al ensamblador la dirección (de memoria de programa) donde se guardará la instrucción que vaya a continuación. Por ejemplo:
Código:
ORG 00H
CLRF VARIABLE1
Código:
bsf PORTB,3
GOTO: Salta a la dirección k de programa.
Código:
goto ENCENDIDO
Código:
clrf PORTA
END: Se escribe al final del programa para indicar que ya ha acabado. (es obligatorio, si no da error).
#DEFINE: Otra instrucción para el ensamblador que usaremos será la instrucción #DEFINE. Es parecido a EQU, solo que aquí no ponemos etiquetas a un registro, podemos ponerla a una instrucción entera, Por ejemplo:
Código:
#DEFINE BANCO1 BSF STATUS,5
#DEFINE BANCO0 BCF STATUS,5
Etiquetas a direcciones de Programa: muy útiles para usar con instrucciones CALL (Llamada a subrutina) o GOTO (Salto).
Código:
[.........]
BTFSC VARIABLE1,0 ;Si el bit 0 de VARIABLE1 es "0" se salta la siguiente instrucción
GOTO ESUNO ;Salta a ESUNO solo si el bit 0 de VARIABLE1 es "1" BSF VARIABLE1,0 Si el bit 0 de VARIABLE1 es 0 se ejecuta esta instrucción y el programa sigue por aquí
[.........]
ESUNO ;Etiqueta a una dirección de programa
BCF VARIABLE1,0 ;Si el bit 0 de VARIABLE1 es "1" se ejecuta esta otra instrucción y el programa sigue por aquí
[.........]
Un poco de orden:
Es importante llevar un poco de orden a la hora de escribir el programa, nos ayudará mucho:
* Al principio van los EQU y los #DEFINE, después comenzamos con el programa.
* El programa se escribe en cuatro columnas separadas por tabuladores:
- En la primera columna se ponen las etiquetas a direcjavascript:void(0);ciones de programa
- En la segunda columna se ponen las instrucciones (BSF, CLRF, BTFSC... etc.)
- En la tercera columna se ponen Los registros o parámetros a los que afecta la instrucción.
- En la cuarta columna se ponen los comentarios que creas pertinentes (cuantos mas mejor) seguidos de un punto y coma.
Subrutinas
 | Una subrutina o subprograma es una parte de programa que hace algo concreto y se repite a menudo, para ahorrar memoria y esfuerzo y para hacer el programa mas comprensible se agrupa en forma de subrutina. Una subrutina se debe ejecutar siempre llamándola con la instrucción CALL y al final de dicha subrutina debe haber siempre un RETURN. El esquema de la derecha muestra como funcionan las subrutinas: Durante el programa principal se llama varias veces a la subrutina SUBR (el nombre es lo de menos) con la instrucción CALL. Cuando el pic ejecuta una instrucción CALL se guarda en memoria la dirección de código de programa a la que tiene que retornar de tal forma que cuando se encuentra con la instrucción RETURN vuelve al programa principal donde lo dejó. Una subrutina no solo puede ser llamada desde el programa principal, también puede hacerse desde otra subrutina (una subrutina que llama a otra subrutina) o desde una interrupción (enseguida las veremos). El siguiente ejemplo muestra un programa que utiliza una subrutina de retardo a la que llama DELAY. Esta subrutina de retardo se hace decrementando el registro CUENTA2 desde FFh hasta 00h 16 veces (las veces que se decrementa CUENTA2 son contadas hacia atrás por CUENTA1) De esta forma se consigue perder tiempo (el tiempo perdido con esta subrutina depende de la frecuencia a la que opere el pic) |
Cuando se produce una interrupción el pic deja automáticamente lo que esté haciendo, va directo a la dirección 04h de programa y ejecuta lo que encuentre a partir de allí hasta encontrarse con la instrucción RETFIE que le hará abandonar la interrupción y volver al lugar donde se encontraba antes de producirse dicha interrupción.
Para que se pueda producir una interrupción hay que habilitar las interrupciones globalmente y la interrupción en concreto que queremos utilizar (con el registro INTCON). Este pic tiene 4 tipos de posibles interrupciones:
Por cambio en los bits RB4-RB7
Por el estado de RB0
Por desbordamiento del Timer-contador
Por fin de ciclo de escritura de la EEPROM de datos
Mientras se está ejecutando una interrupción no se puede producir otra interrupción, el pic no lo permite.
Una cosa importante a tener en cuenta al usar interrupciones es que cuando estas se producen podríamos estar trabajando con registros que pueden ser modificados en la propia interrupción, como el acumulador o el STATUS. Para que la interrupción no eche a perder el buen funcionamiento del programa principal conviene guardar los valores de estos registros en otras variables que no vayamos a modificar. Antes de salir de la interrupción volvemos a restaurar los valores guardados y todo solucionado.
El siguiente ejemplo muestra un programa que usa la interrupción por cambio en el puerto B (En pines RB4 a RB7)
Timer - Contador TMR0
El registro TMR0 puede contar ciclos de instrucción interna o pulsos de entrada por RA4 según el valor del bit 5 del registro OPTION ( TOCS ). Si este bit está a "1" TMR0 cuenta pulsos por RA4 y se le llama Contador; si el bit está a "0" cuenta ciclos de instrucción interna y se le llama Timer.
Cada ciclo de instrucción dura 4 veces el ciclo del reloj del pic (para un reloj de 4MHz ==> Ciclo reloj=0,25 µSeg ==> Ciclo instrucción = 4 X 0,25 = 1µSeg)
Cuando lo usamos como contador (Por RA4) podemos determinar si el incremento se hará por flanco ascendente o descendente con el bit 4 del registro OPTION ( TOSE )
Podemos leer o escribir el registro TMR0 en cualquier momento. Cuando escribamos en él deja de contar durante dos ciclos, cuando lo leamos no pasa nada.
Podemos asignar el prescaler al TMR0 , si hacemos esto podemos elegir el factor en el que se verá dividido el conteo mediante los bits del 0 al 2 del registro OPTION según la tabla del factor de división . Por ejemplo, si elegimos un factor de división de 1/2 tienen que entrar 2 pulsos para que TMR0 se incremente en uno, si está a 1/4 tienen que entrar 4... etc.
También podemos utilizar la interrupción que se produce cuando se desborda el TMR0 , es decir, cuando pasa de FFh a 00h. (se configura desde el registro INTCON )
Pulsadores e interruptores -REBOTES-
Es muy normal usar pulsadores o interruptores en alguna de las entradas del pic para controlarlo. Estos pulsadores no hacen una conexión perfecta e instantánea como podemos pensar: un pulsador se compone de dos partes de metal que entran en contacto (choca una con la otra) al accionarlo. Este choque genera unos pequeñísimos rebotes que suceden tan rápido que son imperceptibles para nosotros, Sin embargo, no lo son para el PIC que trabaja a esas velocidades. Esto es un problema muy común que puede volvernos locos si no lo conocemos pero que resolverás sin problemas
La solución es fácil, basta con añadir un retardo en nuestro programa desde que se detecta el primer pulso hasta que se vuelve a leer la entrada del pulsador. Dicho retardo debe ser suficientemente largo para asegurar que cuando finalice ya se hayan extinguido los rebotes, pero también suficientemente corto para que sea imperceptible para nosotros.
En este ejemplo se cuentan los pulsos introducidos al PIC por RB0. El esquema es el siguiente:
Cuando se acciona el pulsador la entrada RB0 se pone a "0". Para evitar contar los rebotes se llama a una subrutina de retardo llamada REBOTE, esta subrutina funciona bien para osciladores de 4MHz.
Código:
;************************************
;* http://www.electron.es.vg *
;************************************
;* EJEMPLO 5: EVITANDO REBOTES *
;************************************
;* El siguiente programa cuenta las *
;* veces que se acciona un pulsador *
;* conectado a RB0 y Previene los *
;* rebotes del mismo mediante la *
;* subrutina de retardo REBOTE *
;************************************
STATUS EQU 03H
TRISB EQU 05H
PORTB EQU 05H
CUENTA EQU 0CH ;Registro donde contaremos
RETARDO EQU 0DH ;Registro para el retardo
F EQU 1
w EQU 0
#DEFINE BANCO0 BCF STATUS,5
#DEFINE BANCO1 BSF STATUS,5
ORG 00H
BANCO1 ;Pasamos al banco 1
BSF TRISB,0 ;Configuramos RB0 como Entrada
BANCO0 ;Volvemos al banco 0
CLRF CUENTA ;Pone a cero la cuenta
INICIO BTFSS PORTB,0 ;si RB0 es "1" salta la siguiente instrucción
CALL SUMA1 ;Llama a la subrutina SUMA1 (porque RB0 es "0" y,
;por lo tanto, se ha accionado el pulsador)
GOTO INICIO ;vuelve a INICIO
;================================================
; SUMA1: Subrutina que suma uno al registro
; CUENTA y espera a que se suelte el
; pulsador conectado a RB0. Tiene en
; cuenta los rebotes
SUMA1 INCF CUENTA,F ;Incrementa el registro CUENTA
CALL REBOTE ;Llama a la subrutina que previene los rebotes
ESPERA BTFSS PORTB,0 ;\
GOTO ESPERA ; }Espera a que se suele el pulsador para retornar
RETURN ;/
; Fin de SUMA1
;================================================
;================================================
; REBOTE: Subrutina que hace una pequeña
; temporización para prevenir
; los rebotes
REBOTE MOVLW 0FFH ;Carga el acumulador con 0FFh
MOVWF RETARDO ;Mueve el contenido del acumulador a RETARDO
REBO DECFSZ RETARDO,F ;\
GOTO REBO ; }No retorna hasta que RETARDO llega a cero
RETURN ;/
; Fin de REBOTE
;=================================================
END ;Indica final del programa
En fin, espero que haya servido de algo :- D
En línea
