Resumen Y Ejemplos

Conjunto de instrucciones del PIC 16F628 (16F628A) February 15, 2007 at 11:05 pm | In Ensamblador, MPASM |

Como ya hemos visto, para que el microcontrolador lleve acabo una tarea, debemos indicarle exactamente que debe hacer, o en otras palabras, debemos escribir el programa que el micro ejecutara. Ya hemos visto varios ejemplos y muchas de las instrucciones del pic, pero ahora veremos las 35 instrucciones del ensamblador mpasm. Estas 35 instrucciones son las mismas para toda la gama media de los microcontroladores pic asi que si mas adelante se quiere realizar un programa para un pic 16F877 se usaran las mismas instrucciones. Antes de continuar es necesario definir algunos terminos que se usaran para explicar las instrucciones: f: cualquier registro del microcontrolador W: registro de trabajo b: posicion de un bit en el registro ‘f’ d: destino, puede ser ‘f’ (d=1) o ‘W’ (d=0) etiqueta: grupo de caracteres que marcan el inicio de una parte del programa []: opcional : posicion de un bit dentro de un registro Instrucciones orientadas a registros ADDWF: Suma W y f Suma el contenido del registro ‘W’ y el registro ‘f’. Si “d” es 0, el resultado se almacena en el registro W. Si ‘d’ es 1 el resutado se almacena en el registro ‘f’. Sintaxis: [etiqueta] ADDWF f,d Operación: (W) + (f) –> (destino) Flags afectados: C, DC, Z Ejemplo: ADDWF REG,1 Antes de la instrucción: W=0×03, REG=0×04 Después de la instrucción: W=0×03, REG=0×07 ANDWF: W AND f Realiza la operación lógica AND entre el registro W y el registro “f”. Si “d” es 0 el resultado se almacena en el registro W. Si “d” es 1, el resultado se almacena en el registro “f”. Sintaxis: [etiqueta] ANDWF f,d Operación: (W) AND (f) –> (destino) Flags afectados: Z Ejemplo: ANDWF REG,1 Antes de la instrucción: W=0×17, REG= 0xC2 Después de la instrucción: W=0×17, REG= 0×02 CLRF: Borra un registro Borra el contenido del registro ‘f’ y se activa el flag Z. Sintaxis: [etiqueta] CLRF f Flags afectados: Z Ejemplo: CLRF REG

Antes de la instrucción: REG=0×54 Después de la instrucción: REG=0×00, Z=1 CLRW: Borra el registro de trabajo W Borra el contenido del registro ‘W’ y se activa el flag Z. Esta instruccion no tiene operandos. Sintaxis: [etiqueta] CLRW Flags afectados: Z Ejemplo: CLRW Antes de la instrucción: W=0×54 Después de la instrucción: W=0×00, Z=1 COMF: Complementa el registro f El contenido del registro ‘f’ se complementa. Si d=0 el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’. Sintaxis: [etiqueta] COMF f,d Flags afectados: Z Ejemplo: COMF REG,0 Antes de la instruccion: REG=0×13 Después de la instrucción: REG=0×13, W=0xEC DECF: Decrementa f en 1 De decrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’. Sintaxis: [etiqueta] DECF f,d Flags afectados: Z Ejemplo: DEC CONT, 1 Antes de la instrucción: CONT=0×01, Z=0 Después de la instrucción: CONT=0×00, Z=1 DECFSZ: Decrementa en 1 y salta si el resultado es 0 El contenido del registro ‘f’ se decrementa. Si ‘d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución. Sintaxis: [etiqueta] DECFSZ f,d Flags afectados: Ninguno INCF: Incrementa el registro f Incrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’. Sintaxis: [label] INCF f,d Flags afectados: Z Ejemplo: INCF CONT,1 Antes de la instrucción: CONT=0xFF, Z=0 Después de la instrucción: CONT=0×00, Z=1 INCFSZ: Incrementa en 1 y salta si el resultado es 0 El contenido del registro ‘f’ se incrementa. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución.

Sintaxis: [etiqueta] DECFSZ f,d Flags afectados: Ninguno IORWF: W OR f Realiza la operación lógica OR entre el registro W y el registro ‘f’. Si d=0 el resultado se almacena en el registro W. Si d=1, el resultado se almacen en el registro ‘f’. Sintaxis: [etiqueta] IORWF f,d Flags afectados: Z Ejemplo: IORWF REG,0 Antes de la instrucción: REG=0×13, W=0×91 Después de la instrucción: REG=0×13, W=0×93 MOVF: Mover el registro f El contenido del registro ‘f’ se mueve al destino ‘d’. Si d=0, el destino es el registro W. Si d=1, el destino es el propio registro ‘f’. Sintaxis: [etiqueta] MOVF f,d Flags afectados: Z Ejemplo: MOVF REG,0 Después de la instrucción: W=REG RLF: Rota el registro f a la izquierda El contenido del registro ‘f’ se rota una posición a la izquierda. El bit de más peso pasa al carry y el carry se introduce por el bit de menos peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’. Sintaxis: [etiqueta] RLF f,d Flags afectados: C Ejemplo: RLF REG,1 Antes de la instrucción: REG=b’11100110′, C=0 Después de la instrucción: REG=b’11001100′, C=1 RRF: Rota el registro f a la derecha El contenido del registro ‘f’ se rota una posición a la derecha. El bit de menos peso pasa al carry y el carry se introduce por el bit de más peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’. Sintaxis: [etiqueta] RLF f,d Flags afectados: C Ejemplo: RLF REG,1 Antes de la instrucción: REG=b’11100110′, C=0 Después de la instrucción: REG=b’01110011′, C=0 SUBWF: Resta f - W Resta el contenido del registro ‘f’ menos el contenido del registro W. Si d=0, el resultado se almacena en el registro W. Si d=1, el resultado se almacena en el registro ‘f’. Sintaxis: [etiqueta] SUBWF f,d Flags afectados: C, DC, Z Ejemplo: SUBWF REG,1 Antes de la instrucción: REG=0×01, W=0×02 Después de la instrucción: REG=0xFF, W=0×02

SWAPF: Intercambio de f El nibble bajo del registro ‘f’ se intercambia con el nibble alto del mismo. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’. Sintaxis: [etiqueta] SWAPF f,d Flags afectados: Ninguno Ejemplo: SWAPF REG,1 Antes de la instrucción: REG=0×54 Después de la instrucción: REG=0×45 XORWF: W XOR f Realiza la función lógica OR exclusiva entre el contenido del registro W y el registro ‘f’. Si d=0, el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’. Sintaxis: [etiqueta] XORWF f,d Flags afectados: Z Ejemplo: XORWF REG,1 Antes de la instrucción: REG=0xAF, W=0xB5 Después de la instrucción: REG=0×1A, W=0xB5 NOP: No operacion No realiza ninguna operacion, solo consume un ciclo de reloj Sintaxis: [etiqueta] NOP Instrucciones orientadas a bits BCF: Borra un bit Borra el bit ‘b’del registro ‘f’ Sintaxis: [etiqueta] BCF f,b Ejemplo: BCF REG,0 Antes de la instrucción: REG=b’01101101′ Después de la instrucción: REG=b’01101100′ BSF: Activa un bit Activa el bit ‘b’ del registro ‘f’ Sintaxis: [etiqueta] BSF f,b Ejemplo: BSF REG,2 Antes de la instrucción: REG=b’01001001′ Después de la instrucción: REG=b’01001011′ BTFSC: Checa un bit y salta si es 0 Si el bit “b” del registro “f” es 0, se salta una instrucción y se continúa con la ejecución. Sintaxis: [etiqueta] BTFSC f,b BTFSS: Checa un bit y salta si es 1 Si el bit “b” del registro “f” es 1, se salta una instrucción y se continúa con la ejecución. Sintaxis: [etiqueta] BTFSS f,b Instrucciones orientadas a constantes y de control

ANDLW: W AND literal Realiza la operación lógica AND entre el registro W y la constante “k”. El resultado se almacena en el registro W. Sintaxis: [label] ANDWL k Flags afectados: Z Ejemplo: ANDLW 0×5F Antes de la instrucción: W=0xA3 Después de la instrucción: W=0×03 CALL: Llamada a subrutina Llamada y salto a subrutina. La dirección de retorno se guarda en el stack. La constante “k” de 8 bits forma la dirección de salto y se carga en los bits del PC. Los bits del PC se cargan con los bits del registro “STATUS”. PC se pone a 0. Sintaxis: [etiqueta] CALL k Ejemplo: INICIO CALL DESTINO Antes de la instrucción: PC=INICIO Después de la instrucción: PC=DESTINO CLRWDT: Borra el watchdog timer Esta instrucción borra tanto el “watchdog” como el prescaler. Los bits TO y PD del registro de estado se ponen a “1″. Sintaxis: [label] CLRWDT Flags afectados: TO, PD GOTO: Salto incondicional Se trata de un salto incondicional. Los 9 bits de la constante “k” que forman la instrucción, se cargan en los bits del PC y forman la dirección de salto. Los bits del PC se cargan con los bits del registro de estado. Sintaxis: [etiqueta] GOTO k Ejemplo: INICIO GOTO DESTINO Antes de la instrucción: PC=0 Después de la instrucción: PC=DESTINO IORLW: W OR literal Se realiza la función lógica OR entre el registro W y la contante “k”. El resultado se almacena en el registro W. Sintaxis: [etiqueta] IORLW k Flags afectados: Z Ejemplo: IORLW Ox35 Antes de la instrucción: W=0×9A Después de la instrucción: W=0xBF MOVLW: Carga un literal en W El registro W se carga con el valor de 8 bits expresado mediante la literal “k”. Sintaxis: [etiqueta] MOVLW k Ejemplo: MOVLW 0×5A Después de la instrucción: W=0×5A

RETURN: Regresa de una subrutina El programa regresa de la subrutina y ejecuta la instruccion que sigue a CALL Sintaxis: [etiqueta] RETURN RETLW: Regresa de una subrutina y carga el valor K en W El programa regresa de la subrutina y carga el valor de 8 bits del registro k en el registro W Sintaxis: [etiqueta] RETLW,k Ejemplo: RETLW,0×45 Antes de la instruccion: W=xx Despues de la instruccion: W=0×45 RETFIE: Regresa de la rutina de servicio Sintaxis: [etiqueta] RETFIE SLEEP: Entra en estado de reposo Al salir, activa el bit de estado TO y borra el PD. El WDT y el prescaler se borran.Al entrar en el modo SLEEP, se detiene el oscilador. Sintaxis: [etiqueta] SLEEP Flags afectados: TO, PD, GPWUF XORLW: W XOR literal Realiza la función lógica OR exclusiva entre el contenido del registro W y la constante “k” de 8 bits. El resultado se almacena en el registro W. Sintaxis: [etiqueta] XORLW k Flags afectados: Z Ejemplo: XORLW 0xAF Antes de la instrucción: W = 0xB5 Después de la instrucción: W = 0×1A SUBLW: Resta L - W A una constante “k” de 8 bits se le resta el registro W. El resultado es guardado en el mismo registro W. Sintaxis: [etiqueta] SUBLW k Flags afectados: C,DC,Z MOVWF: Mover el valor del registro W al registro f El contenido del registro ‘W’ se mueve al registro ‘f’. Sintaxis: [etiqueta] MOVWF f Flags afectados: Ninguno Ejemplo: MOVWF REG Antes de la instrucción: REG=0×03, W=0xA4 Después de la instrucción: REG=0xA4, W=0xA4

Y estas son las 35 instrucciones que podemos utilizar para programar los microcontroladores PIC. La razon para que solo se utilicen 35 instrucciones en la programacion es que los PIC son microcontroladores RISC, y estas instrucciones estan bien optimizadas para tener una mayor velocidad de trabajo, una arquitectura mas simple y un codigo mas compacto.

Retardos por software February 9, 2007 at 4:53 pm | In Tutorial |

La semana pasada, en la segunda parte del tutorial 1, se habló un poco sobre los retardos por software. Ahora vamos a ver esto de la lógica de los retardos un poco más a fondo para poder crear nuestras propias subrutinas. Como ya se dijo el pic 16F628A tiene un oscilador interno de 4MHz, si utilizamos ese oscilador tenemos que todas las instrucciones se ejecutan en 1uS, exceptuando los saltos que tardan 2 ciclos, es decir 2uS. Tomando en cuenta eso vamos a generar nuestros retardos, pero siempre partiendo de la suposición de que se esta trabajando a una frecuencia de 4MHz, si es así, crear rutinas de retardo para nuestro pic es muy sencillo. Supongamos que tenemos la siguiente rutina:

A la derecha de cada instrucción aparece el número de ciclos que tomará cada una. Las primeras dos toman solamente 1 ciclo, la tecera decfsz toma (N-1)+2, porque decrementará N-1 veces la variable N y en el último decremento hará un salto, es por eso el +2. La instrucción goto se ejecuta en 2 ciclos y se ejecutará N-1 veces, es por eso que se toma como 2*(N-1). De esta forma tenemos que el número de ciclos, y por lo tanto el tiempo que tendremos de retardo está dado por la siguiente expresión: 1+1+(1)(N-1)+2+(2)(N-1) , ó 4+N-1+2N-2, o lo que es lo mismo 3N+1. Si queremos un retardo de 100uS entonces tenemos que 3N+1=100, despejando tenemos N=(1001)/3=33, asi que para tener un retardo de 100uS el valor de la variable N debe ser 33. Ahora veamos esta rutina:

Podemos darnos cuenta que ahora nuestra rutina original (desde CICLO2 hasta goto CICLO) está afectada por la variable M, así que es como si M multiplicara a nuestro retardo. Para saber el nuevo valor del retardo de nuevo sumamos todos los ciclos, tomando en cuenta que M multiplica al retardo original de modo que la expresión ahora queda de la siguiente manera: [3N+1]M+1+1+(1)(M-1)+2+(2)(M-1), o lo que es lo mismo [3N+1]M+3M+1, de manera que tenemos dos retardos anidados. Para saber

cuanto sería el retardo total primero calculamos el retardo básico, si queremos que ese retardo sea de 100uS entonces N=33, si ahora queremos que el retardo total sea de 10mS entonces ocupamos completar 10000 ciclos, así que igualamos nuestra expresión a ese número: [(3*33)+1]M+3M+1=10000, despejando tenemos M=(9999)/103, esto es aproximadamente igual a 97, así que para un retardo de 10mS nuestra variable N debe valer 33 y la variable M debe tener un valor de 97. Así podemos seguir anidando retardos. Para obtener un retardo de 1 segundo utilizaremos la siguiente rutina:

Aqui vemos que la variable P afecta a los dos retardos que ya habíamos definido de modo que la expresión para calcular el nuevo retardo total seria [(3N+1)M+3M+1 ] P+1+1+(1)(P-1)+2+(2)(P-1), y reduciendo terminos la expresion seria [(3N+1)M+3M+1]P+3P+1. Queremos un retardo de 1 segundo, esto son 1000000 ciclos, por lo que nuestra expresión del retardo debe ser igual a un millón: [(3N+1)M+3M+1 ]P+3P+1=1000000. Sustituyendo N y M tenemos 9995P+1=1000000, entonces tenemos que P=(999999)/9995 y P entonces es aproximadamente igual a 100. Esta no es la forma más precisa de realizar retardos, utilizando los valores para las variables N, M y P que calculamos tenemos que al final del retardo solamente se realizaron 999501 ciclos, en tiempo esto es aproximadamente igual a 0.99 segundos pero no el segundo completo, sin embargo para aplicaciones que no necesitan una gran precisión este metodo funciona, y funciona muy bien!

Tutorial 1 - LED’s (segunda parte) February 2, 2007 at 8:58 am | In Tutorial |

Tutorial 1.2 - Encendiendo y apagando LED’s… ahora con retardo! Como ya dijimos hay algo que no funciona bien en el programa anterior. Cada instrucción ocupa 1 ciclo de reloj para ejecutarse. Como utilizamos el reloj interno del 16F628A cada instrucción se ejecuta en (1/4MHZ)*4 o lo que es lo mismo 1uS. El programa ejecuta 5 instrucciones mientras los leds estan encendidos y otras 5 mientras están apagados, asi que encienden 5uS y apagan otros 5uS. Al ver el ejemplo en funcionamiento veremos q ue los leds nunca se apagan, ¿cómo hacemos para que esto se alcance a ver? La respuesta: utilizando un retardo al encender los leds y otro al apagarlos. El principio del retardo es contar descendentemente desde un número dado y al momento de que la cuenta llega a cero dejar de contar. El cero indica el fin del retardo y una vez concluido puede continuar la ejecución del programa. Lo primero es definir una constante que usaremos como contador, llamemosla CUENTA. Es importante aclarar que al momento de definir la constante con la directiva equ lo que hacemos es declarar la dirección del registro que usaremos como CUENTA. Esto es que si declaramos CUENTA equ 0×20 no significa que cuenta vaya a valer 0×20, sino que en esa dirección estará ese registro. Después podremos cargarle a CUENTA cualquier valor que querramos, por ejemplo MOVLW 0xFF y después MOVWF CUENTA, así nuestro registro CUENTA, en la dirección 0×20, tendrá un valor de 255 decimal. El PIC 16F628A cuenta con algunos registros de propósito general que podemos utilizar directamente en nuestros programas para guardar los datos que estamso usando. Estos registros empiezan desde la dirección 0×20 del banco 0, es por eso que CUENTA la definimos en esa dirección. Cada vez que definamos una constante o una variable debe mos definirla después de la dirección 0×20 ya que de otro modo el programa no va a funcion ar. Habiendo declarado la constante CUENTA y después de cargar ese registro con un valor podemos realizar la rutina de retardo. Para eso decrementamos CUENTA por 1 hasta que el valor llegue a 0. De esto se encarga la instrucción decfsz. Su sintaxis es decfsz f,d donde f es el registro que queremos decrementar y d es el destino en el que guardamos el resultado, si d=0 el resultado se guarda en el registro W, si d=1 el resultado se guarda en el mismo registro f. decfsz CUENTA,1 decrementa el valor de CUENTA en 1 y guarda el resultado en el mismo registro CUENTA. Para asegurarnos de que decfsz se ejecute hasta que el registro llegue a 0 utilizamos la instrucción goto para estar volviendo hasta que la cuenta termine. Entonces el nuevo código queda de la siguiente manera (descargar código):

Ahora las únicas instrucciones nuevas son call y return. call se utiliza para mandar llam ar una rutina, en este caso la rutina de retardo. Utilizar rutinas hacen que el código sea más pequeño y entendible. call Retardo genera que la ejecución del programa salte hacia la subrutina con la etiqueta Retardo, se ejecuta el código de la subrutina y después la instrucción return se encarga de regresar la ejecución del programa a la línea que seguía de la instrucción call. Así funcionan las subrutinas. Este tutorial sirve para explicar un poco la lógica de los retardos, sin embargo calcular retardos de esta manera puede ser un poco complicado, lo bueno es que existen algunos generadores de retardo a los que solo se les especifica el reloj que se utiliza y el tiempo que se desea de retardo y con esa información se genera el código necesario para el retardo. Un gerador muy bueno es este: Delay Code Generator.

Ejemplos Dices que quieres poner los 5 bits del puerto A como salida, no especifícas que 5 bits, el pic 16f628a tiene 7 pines en el puerto A que pueden ser salida, esos son los bits 0,1,2,3,4,6,7, el pin RA5 (es decir el bit 5) solo funciona como salida. Muy bien, aclarado eso te digo como configurar un bit como entrada o como salida, eso se configura con los registros TRISx que se encuentran en el banco 1, es decir que para configurar el puerto A como entrada o salida debes configurar el registro TRISA, escribiendo un 1 en un bit del registro TRISA ese bit del puerto A se configura como entrada, escribiendo un 0 se configura como salida. Si quieres configurar los primeros 5 bits del puerto A lo puedes hacer de varias formas, por ejemplo: -Forma 1 bsf STATUS,RP0 ; Cambio al banco 1 bcf TRISA,0 ; Bit 0 del puerto A como salida bcf TRISA,1 ; Bit 1 del puerto A como salida bcf TRISA,2 ; Bit 2 del puerto A como salida bcf TRISA,3 ; Bit 3 del puerto A como salida bcf TRISA,4 ; Bit 4 del puerto A como salida bcf STATUS,RP0 ; Cambio al banco 0 - Forma 2 bsf STATUS,RP0 ; Cambio al banco 1 movlw b’00011111′ movwf TRISA bcf STATUS,RP0 ; Cambio al banco 0 - Forma 3 bsf STATUS,RP0 ; Cambio al banco 1 clrf TRISA ; Todo el puerto A como salida bcf STATUS,RP0 —Asi puedes configurar el puerto A, las primeras dos formas funcionan igual, configuran los primeros 5 bits (del 0 al 4) del puerto como salida mientras que la tercera configura el puerto completo como salida, espero que haya quedado claro.