Aqueronte: Baseline. ProgBasico 4.

En este programa, se va a utilizar las siguientes instrucciones:

COMF: Complemento de bits

BCF: Poner un bit a cero.

RLF: Rotar hacia la izquierda con bit de Carry.

RRF: Rotar hacia la derecha con bit de Carry.

BTFSS: Instrucción de salto si un bit de un registro es uno.

Para la realización de este programa, se ha utilizado el microcontrolador PIC10F200, cuyas características expuestas por Microchip, se pueden observar en la siguiente dirección: PIC10F200.

El programa es el siguiente:

;**********************************************************************
;                      AqueronteBlog@gmail.com                        *
;                                                                     *
;   Este archivo es propiedad intelectual del blog Aqueronte,         *
;   cuya dirección web, es la siguiente:                              *
;                                                                     *
;                   http://unbarquero.blogspot.com/                   *
;                                                                     *
;   Se permite cualquier modificación del archivo siempre y cuando    *
;   se mantenga la veracidad de su autor.                             *
;                                                                     *
;   El autor no se responsabiliza de las consecuencias que pueda      *
;   ocasionar éste código debido a un uso inadecuado del mismo.       *
;**********************************************************************
;                                                                     *
;    Filename:      Ejemplo4.asm                                      *
;    Date:          10-Julio-08                                       *
;    File Version:  vs0.0                                             *
;                                                                     *
;    Author:        Manuel Caballero                                  *
;    Company:       Hades                                             *
;                                                                     *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Files Required: P10F200.INC                                      *
;                                                                     *
;**********************************************************************
;                                                                     *
;    Notes: En este programa, se muestra la utilización de las        *
;           instrucciones comf, bcf, rlf, rrf y btfss.                *
;**********************************************************************

   list      p=10F200              ; Directiva para definir el procesador
   #include < p10F200.inc >        ; Registros especificas del procesador

   __CONFIG   _MCLRE_ON & _CP_OFF & _WDT_OFF & _IntRC_OSC

; _MCLRE_ON:  Reset externo ACTIVADO.
; _CP_OFF:    Protección del código DESACTIVADO.
; _WDT_OFF:   Watchdog DESACTIVADO.
; _IntRC_OSC: Oscilador interno de 4MHz.

;***** DEFINICIÓN DE VARIABLES

   cblock  10h      ; Dirección de inicio de memoria RAM
   Var
  endc

;**********************************************************************
   ORG     0xFF      ; Valor del oscilador interno

; El valor del oscilador interno se localiza en la dirección 0xFF
; como una instrucción movlw k, donde k es el valor de configuración del oscilador.

  ORG     0x000        ; Inicio de código
  movwf   OSCCAL       ; Actualiza el valor del oscilador interno a 4MHz 
 movlw   b'11111110' ; W = 0xFE 
 movwf   Var          ; Var = 0xFE 
 comf    Var,F        ; Var = #Var = 0x01 
 bcf     STATUS,C ; RESET Bit de Carry: C = 0

Izquierda 
 rlf     Var,F 
 btfss   STATUS,C ; ¿C = 1?    
 goto    Izquierda ; NO -> Vuelve a Izquierda
         
Derecha 
 rrf     Var,F 
 btfss   STATUS,C ; ¿C = 1? 
 goto    Derecha      ; NO -> Vuelve a Derecha  

 goto    Izquierda

  END                  ; directiva 'fin de programa'

Para la realización de este programa, se ha empleado una variable definida en memoria RAM mediante las instrucciones.

cblock---endc

Dicha variable se ha llamado Var, en la cual se cargará el valor 0xFE.

Para ver el resultado, compilamos el código y seleccionamos el MPLAB SIM para poder simularlo.

Abrimos la ventana de Watch y seleccionamos en la categoría de Symbol la variable definida como Var, y el la categoría de SFR, los registros WREG y STATUS.

Simulamos el código paso a paso.

La primera consideración, es usar la instrucción de complemento, para ello, empleamos la variable definida en la memoria RAM llamada Var. Cuando el programa llegue a la instrucción:

comf Var,F

El contenido almacenado en Var se complementará, es decir, los '0' pasan a ser '1' y viceversa, por lo tanto, una vez ejecutada la instrucción de complemento, la variable Var almacenará el valor 0x01.

El siguiente paso es limpiar el bit de Carry del registro STATUS, ya que se va a emplear las instrucciones de rotar tanto a la derecha como a la izquierda, y éstas están influídas por dicho bit.

Por lo tanto, para seguridad de que el programa se ejecute de una forma correcta, se realiza una puesta a cero del bit de Carry mediante la instrucción de puesta a cero de bits:

bcf STATUS,C

Lo que resta de programa es mover el bit almacenado en la variable Var hacia la derecha y hacia la izquierda.

Para mover el bit hacia la izquierda, está el bloque definido como Izquierda, cuyas sentencias de código son las siguientes:

Izquierda

   rlf   Var,F

   btfss STATUS,C ; ¿C = 1?

   goto  Izquierda ; NO -> Vuelve a Izquierda

Rotaremos el bit hacia la izquierda con la instrucción:

rlf   Var,F

Cuando se ejecute, el bit almacenado e la variable Var se desplazará una posición hacia la izquierda:

Esta operación de desplazamiento de bit hacia la izquierda estará controlada por la siguiente instrucción:

btfss STATUS,C

La cual estará comprobando si el bit C, bit de Carry, del registro STATUS se pone a '1'. En caso que no sea así, mientras C = 0, se ejecutará la instrucción siguiente, en caso contrario, C = 1, se saltará la instrucción siguiente.

Por lo tanto, el bit almacenado en Var se desplazará hacia la izquierda siete veces, a la octava vez que se ejecute la instrucción de desplazamiento hacia la izquierda, el bit de Carry se pondrá a '1' y por lo tanto, se saltará al bloque de Derecha.

Una vez se halla "disparado" el bit de Carry, se pasará al bloque de desplazar el bit hacia la derecha.

Derecha 
 rrf     Var,F 
 btfss   STATUS,C ; ¿C = 1? 
 goto    Derecha      ; NO -> Vuelve a Derecha

Una consideración a tener en cuenta, es que las instrucciones, como ya se ha comentado anteriormente, de rotación de bits, están influenciadas por el bit de Carry del registro STATUS, es decir, lo que esté almacenado en dicho bit C, se introducirá al registro que se esté manipulando mediante las instrucciones de rotación de bits.

Es decir, en este punto del programa, el contenido de Var es 0x00 y el bit de Carry es '1', como se puede apreciar en la anterior figura, por lo tanto, al ejecutarse la instrucción: