Tutorial microontroladores PIC.
Tutorial Microcontrolador PIC.
Tercera parte.
 

         En la parte anterior vimos como inicializar un PIC, ahora, usando esa información haremos un pequeño programa el cual solo encenderá un LED según el interruptor que se presione.

        Lo primero es visualizar lo que queremos,  (ordenar nuestro pines de entrada y salida por ejemplo) y según eso empezar a trabajar.

Figura 3: Circuito a implementar.

            Según el circuito anterior, vemos que el puerto A lo usaremos como entrada y el puerto B como salida, a los cuales hemos conectado LED'S para poder ver los resultados.

            El puerto A está conectado directamente a la alimentación con lo cual sabemos que normalmente tiene una entrada de +5 V ( 1 lógico) y al activarse el interruptor tendremos un 0 lógico.

            Nota: Es muy importante que todos los pines de entrada queden bien definidos si están en un nivel alto o bajo por que de lo contrario el PIC entrará en un estado de incertidumbre y no trabajará de manera correcta.
            Los pines de salida, no es necesario que se conecten si no los vamos a usar.
 

Comenzando con el programa.

            Como vimos anteriormente, para abrir una nueva ventana de programación pinchamos en la ventana FILE y le damos a la opción NEW, luego debemos inicializar nuestro PIC, en este caso será:
 

; ****************************************  
; *   Ejemplo tutorial PIC                                     *   
; *  Este programa enciende un led dependiendo *   
; *  de que interruptor sea activado                      *   
; ****************************************   
     list                   p=16f84   
     #include p16f84.inc
port_a               equ 5   
port_b              equ 6   
trisb                  equ 86   
trisa                  equ 85   
retard               equ 11              ;RETARDO   
estado              equ 3   

   
 clrf                  estado   
 clrf                  port_a   
 bsf                  estado,5             ;selección del banco 1   
 movlw             0x1f   
 movwf             port_a               ;define RA0 como entrada   
 clrf                  port_b   
 movlw             0x00   
 movwf            port_b               ;define puerto B como salida   
 bcf                  estado,5   
 clrf                  port_a   
 clrf                  port_b   
 

 
        Luego podemos hacer que vaya preguntando a cada pin de entrada, recordemos que segun nuestro circuito los pines están normalmente en un nivel alto, y en nuestro caso si este esta en un nivel alto hacemos que testee el siguiente, de lo contrario lo mandamos a un subrutina donde encendemos el LED correspondiente.

            Para esto usamos la instrucción btfss (Bit Test F, Skip if Set), es decir, testea el bit f y salta (skip) si esta en un nivel alto (set), el salto se refiere a que la siguiente instrucción no la considera y salta hasta la subsiguiente.

            Al empezar un programa, marcamos el inicio de un bloque, en este caso lo llamaremos "inicio", que original no.

 
inicio     btfss     port_a,0 ;si el bit 0 del puerto a esta en nivel alto se salta una instrucción  

             call        enci0  

             call        retardo  

             btfss     port_a,1 ;si el bit 1 del puerto a esta en nivel alto se salta una instrucción  

             call        enci1  

             call        retardo  

             btfss     port_a,2 ;si el bit 2 del puerto a esta en nivel alto se salta una instrucción  

             call        enci2  

             call        retardo  

             btfss      port_a,3 ;si el bit 3 del puerto a esta en nivel alto se salta una instrucción  

             call        enci3  

             call        retardo  

             btfss      port_a,4 ;si el bit 4 del puerto a esta en nivel alto se salta una instrucción  

             call        enci4  

             call        retardo  

             goto      inicio

            En la primera línea, como dice el comentario adjunto, testea el bit 0 del puerto a, si este esta en un nivel alto entonces el programa se salta una instrucción llegando a la instrucción call (llamar) la cual llama  a una subrrutina llamada retardo, de lo contrario, si está en un nivel bajo el programa considera la siguiente instrucción y ejecuta la instrucción call    enci0, en la cual se activa el pin 0 del puerto b que es el puerto se salida.

            El resto del programa:
 
enci0    movlw    0x00   
            movwf    port_b   
            call         retar2   
            movlw    B'01'   
            movwf    port_b   
            return   
enci1    movlw     0x00   
            movwf    port_b   
            call         retar2   
            movlw    B'10'   
            movwf    port_b   
            return   
enci2    movlw    0x00   
            movwf   port_b   
            call         retar2   
            movlw   B'100'   
            movwf   port_b   
            return   
enci3    movlw     0x00   
            movwf    port_b   
            call         retar2   
            movlw    B'1000'   
            movwf   port_b   
            return   
enci4    movlw   0x00   
            movwf   port_b   
            call         retar2   
            movlw    B'10000'   
            movwf    port_b   
            return  

retardo movlw    0x96   
            movwf    retard   
reta3   decfsz      retard,1   
            goto       reta3   
            return   
   

            end

 


En la primera línea lo que hacemos es cargar un cero en el acumulador: movlw 0x00 (MOVe Literal to W) y luego la información que tiene el acumulador (W) la movemos la puerto b: movwf port_b (MOVe W to F), con esto nos aseguramos el todos los LED's del puerto b están apagados.
En la tercera línea llamamos un retardo, lo cual siempre es bueno hacer para evitar que el pic colapse, este retardo esta casi al finál del programa y el mecanismo de trabajo es muy parecido al anterior:
                1.- Mover el literal 96 (Hexadecimal) en el acumulador,  en otras palabras cargar un 96 en el acumulador.

                2.- Mover el contenido del acumulador al registro retard, el cual fue definido al comienzo de programa y ubicado en la posición 11 en la memoria del pic, ahora el registro retard tiene cargado un 96.

                3.- Decrementar en una unidad el registro retard y el valor resultante se guarda en el mismo registro y cuando el valor de este sea cero, saltar una línea en el programa, con lo cual caerá en la instrucción return con lo cual vuelve a la posición desde donde se llamo a la subrutina.   decfsz      f,d (DECrement F, Skip if Zero) (decrementa el registro indicado y salta si es cero) si el valor de "d" es cero entonces el resultado se guarda en el acumulador, si este valor en cambio es uno entonces el valor se almacena en el mismo registro.

                4.- Luego va al bloque de nombre "reta 3" con lo cual se volverá a decrementar el registro, esto lo hará durante 96 veces hexadecimales, es decir, 150 veces. 

Al volver a la  4ta linea de este bloque movlw  B'01' hacemos algo muy parecido al paso anterior, sólo que ahora cargo un 1 binario en el acumulador y luego movemos esta información al puerto b, con lo cual tendremos en la salida del puerto b un 00001 considerando que se cuenta desde RB4 hasta RB0 por lo tanto se enciende el LED correspondiente al pin 0 del puerto b.
        De esto deducimos que si queremos encender por ejemplo el pin 3 del puerto b, debemos cargar el acumulador con un B'1000' para luego pasar esta información al puerto b.

        Otra alternativa seria: movlw   0x08 ya que 08h = 1000b.

Finalmente debemos guardar este programa, para esto pinchamos en la opcion File y luego en Save As y elegimos el directorio y un nombre, en este caso le pondremos ejemplo.asm

                                                              Figura 4
Pincha aqui para bajar el programa en formato ASM
 

        En la siguiente parte veremos como compilar este programa y detectar los errores de programación.
 

Ir a la pagina principal           Pagina anterior           Pagina siguiente
Página Principal               Volver                   Siguiente
 
  
 
 
By:    Alvaro A. Vera Sch.