FASE 4: Implementación del Juego

I. CAPACIDAD TERMINAL

  • Utilizar al microcontrolador en aplicaciones de control electrónico.
  •  Desarrollar y ejecutar programas en un microcontrolador PIC
  • Programar y configurar interfaces básicas del microcontrolador.

II. COMPETENCIA ESPECIFICA DE LA SESION

  •  Conocer el uso de las subrutinas
  • Conocer las técnicas de elaboración de programas a través de algoritmos
  • Programación de un proyecto real.

III. CONTENIDOS A TRATAR

  • Bucles de control
  • Algoritmos
  • Pseudocódigo

IV. RESULTADOS

  • Diseñan y optimizan sistemas y procesos para cumplir con las condiciones establecidas y gestionando adecuadamente los recursos materiales y humanos.

V. MATERIALES Y EQUIPO

  • CCS Compiler instalado.
  •  Entrenador de PICS
  •  PIC16F877A
  •  Guía de Laboratorio. El trabajo se desarrolla de manera GRUPAL.
  •  PC con Software de simulación.

VII. FUNDAMENTO TEÓRICO
  • BUCLES DE CONTROL


VI. TAREAS GUIADAS DENTRO DEL LABORATORIO:

Se nos plantea la PROGRAMACION de un JUEGO DE ENCESTAR con los siguientes
REQUERIMIENTOS:

Se dispone de un DISPLAY de 4 dígitos. Elaborar un programa que INCREMENTE el número
del display cada vez que se presione un pulsador y al llegar al sexto pulso, que emita 3 bips y
el programa se detenga allí hasta que se reinicie dicho programa presionando RESET.
También se pide que al mismo tiempo se encienda un LED cada vez que se presione dicho
pulsador.

Para el desarrollo de este programa, primero se debe determinar las ENTRADAS (sensores) a
los cuales responderá el uControlador y las SALIDAS (actuadores) sobre los cuales ejercerá
alguna acción:




Display contando hasta 6, de ahi suena 3bip y se pone a cero.

Basándose en el ejemplo anterior, implemente un CODIGO a partir del siguiente
PSEUDOCODIGO:
  • Mantener Displays apagados
  • BUCLE INFINITO:
  • Esperar a colocar moneda (presionar una entrada)
  • Si ingresa MONEDA, encender pantalla Displays y tocar BIP
  • Esperar a “encestar” (presionar pulsador)
  • Si se encesta, agregar 7 puntos y sonar BIP
  • Si se supera 50 puntos, sonar BIP 3 veces y apagar DISPLAYS
  • Detener el conteo hasta volver a colocar moneda.

Programa:
include <16f877a.h>             // Incluimos archivo con PIC a utilizar
#use delay (clock=20M)           // Indicamos al compilador que trabajaremos a 20Mhz
#fuses HS, NOPROTECT, NOWDT      // Configuración básica de los fusibles

/******************************************************/

//Variables usadas en las funciones, declaradas como VARIABLES:

/******************************************************/
int tabBCD[10]={0b00111111,0b00000110,0b01011011,0b01001111,0b01100110,0b01101101,0b01111101,0b00000111,0b01111111,0b01101111};          // Completar numeros decodificados
int delay=5;                   // Completar con valor de retardo adecuado en ms
int16 dato=0;                    // Declaramos una variable ENTERA de 16 bits ¿por qué?
int16 unidades=0, decenas=0, centenas=0, u_millar=0;

/*************************************************/
// DECLARACION DE LAS FUNCIONES A UTILIZAR
/************************************************/
void descomp_entero(INT16 valor);
void visualizar(VOID);
void BIP();

/*************************************************/
// FUNCION PRINCIPAL VOID (MAIN)
/************************************************/
void main ()                    
{
   WHILE (INPUT (PIN_D0))
   { output_a (0b00000000); }
  
   IF (!input (PIN_D0))
   {
      visualizar ();
      BIP ();
   }

  
   INT led = 1;
   dato = 0;
   output_c (0);

   WHILE (true)
   {
      IF (!input (PIN_A5))
      {
         dato = dato + 7;
         descomp_entero (dato);
         visualizar ();
         BIP ();
         led = led << 1;
         output_c (led);
         delay_ms (100);

         IF (dato > 50)
         {
            BIP ();
            delay_ms (500);
            BIP ();
            delay_ms (500);
            BIP ();
            delay_ms (500);
         }
       
         WHILE (dato>50)
     
       {  output_a (0b00000000);}
        
      
  
      } visualizar ();
   }
}

/******************************************************/
// Funcion que descompone un número Entero de 4 cifras
/******************************************************/
void descomp_entero(INT16 valor)
{
   u_millar = (INT16) valor / 1000; // 1er Dígito o millar
   valor -= u_millar * 1000;  // y se lo resto al valor
   centenas = (INT16) valor / 100; // 1er Dígito o Centenas
   valor -= centenas * 100;  // y se lo resto al valor
   decenas = (INT16) valor / 10; // 2do Dígito o Decenas
   valor -= decenas * 10;  // y también se lo resto
   unidades = (INT16) valor; // y por último solo me quedan las unidades
}

/*************************************************/
// Funcion para displayar en forma multiplexada
/************************************************/
void visualizar(VOID)
{
   output_b (tabBCD[u_millar]); // sacamos por puerto B las unidades de millar
   output_a (0b00001000);  // activamos display #1
   delay_ms (delay);   // esperamos tiempo para que se muestre dígito
  
   output_b (tabBCD[centenas]) ;
   output_a (0b00000100) ;
   delay_ms (delay) ;
  
   output_b (tabBCD[decenas]) ;
   output_a (0b00000010) ;
   delay_ms (delay) ;
  
   output_b (tabBCD[unidades]) ;
   output_a (0b00000001) ;
   delay_ms (delay) ;
}

/*************************************************/
// Funcion para emitir sonido BIP
/************************************************/
void BIP()
{
   INT i;     // Declaración de VARIABLE LOCAL
   FOR (i = 0; i <= 50; ++i)
   {
      output_high (PIN_E1); // Pone a "1" el pin E1 (envía 5 voltios)
      delay_ms (1);   // "Congela el tiempo" durante 1ms
      output_low (PIN_E1); // Pone a "0" el pin E1
      delay_ms (1);   // "Congela el tiempo" durante 1ms
   }

}

Display contando hasta 49.



Video mostrando las tareas realizadas en laboratorio:

 Link del video:

   https://www.youtube.com/watch?v=234-RS5IdvM




OBSERVACIONES:

·         Observamos que al construir subrutinas, si estas se colocan después de la función principal, deberán declararse al principio del código sino el programa no las reconocerá.
·         Si queremos que todos los displays estén apagados a la hora de empezar nuestro programa debemos mandar a 0 voltios el puerto A.
·         Cuando creamos un bucle for podemos declarar la variable de repetición antes del bucle o dentro mismo. Ejm for (int i,i<10,i++).
·         Algunas veces al grabar el PIC en el programa obtener que la grabación fue exitosa pero a la hora de probar el PIC en el circuito este no funciona, por lo que debemos descartar este PIC ya que no está funcionando correctamente.
·         El botón RESET nos permite empezar de nuevo el código de la función principal.

CONCLUSIONES:
·    En estos 4 laboratorios aprendimos a usar los puertos de entrada y de salida del PIC 16F877A, para la entradas usamos pulsadores que simulan sensores, y para las salidas LEDs que simulan actuadores, como un motor por ejemplo. Todo esto usando valores lógicos 1 y 0s.
·      Aprendimos a programar utilizando las estructuras de control WHILE, FOR, IF, que nos permiten controlar el flujo del programa, tomando decisiones, realizando acciones repetitivas, todo esto dependiendo de las condiciones que nosotros pongamos.
·         Conocimos los principales tipos de variables como el int y el array.
·   Aprendimos que para realizar un algoritmo no existe una única forma, sino, que por diferentes caminos podemos llegar a un mismo resultado. Esto dependerá de nuestra lógica y manera de razonar.
·     Aprendimos también que las entradas y salidas del PIC son activas en bajo, esto quiere decir que para activar una entrada debemos pasarle un 0 lógico. Y la salida se activara si sale un 0 lógico también.





Comentarios

Publicar un comentario

Entradas populares