FASE 3: Programación con Display de 7 segmentos

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 Display de 7 segmentos y su funcionamiento

·         Conocer las técnicas de multiplexación

·         Programar HMI para juego de encestar.

III.        CONTENIDOS A TRATAR

·         Display 7 segmentos

·         Multiplexación de datos

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.

VI.          FUNDAMENTO TEÓRICO

·         Display de 7 segmentos de Ánodo y Cátodo común.

        VII. TAREAS GUIADAS DENTRO DEL LABORATORIO:

               1.    Transcriba el programa mostrado, compile dicho programa, simule en Proteus y compruebe funcionamiento en Tarjeta Entrenadora. Responda a las preguntas planteadas.

2.    Al probar el programa anterior, se verá los números del 1 al 4 mostrándose en los displays. Disminuya el valor de retardo (delay_ms(500)) de tal manera que se vean los 4 displays a la vez. En lugar de cambiar los valores uno por uno, cree una variable entera llamada “display” y asígnele un valor adecuado.

 El valor adecuado es de : 5 ms

3.    Transcriba el programa mostrado, compile dicho programa, simule en Proteus y compruebe funcionamiento en Tarjeta Entrenadora. Responda a las preguntas planteadas.

4.    Corrija el programa anterior para un correcto funcionamiento. Modifique el programa de tal manera que:

Al presionar el pulsador D0, el número aumente en valor de 10; al presionar el pulsador D1, el número aumente en valor de 100 y al presionar E2, el número disminuya en 10 unidades.

5.    Contestar las siguientes preguntas:

¿Es posible contar números negativos? 

Si es posible con la promocionan adecuada, programandole un signo al lado.

¿Qué sucederá si se supera el número 9999?

     Se pudo ver, que cuando pasó el numero 9999, el display que tiene el valor más significativo toma un valor aleatorio, mientras que las otras cifras que le siguen se reinician, es decir vuelven a comenzar desde cero.

 ¿cómo hacer para mostrar números con punto decimal?

                             Se tendrá que activar el punto del display  y a los costados los                                         números; entero y decimal.

VIII.       CONTENIDO DEL INFORME EN EL BLOG:

1.    Descripción de los TIPOS DE VARIABLES: entero, entero con signo, etc.

Ejemplo de variable declarada e inicializada: int i;

Hay que tener en cuenta que la línea tiene que acabar en punto y coma. 

El tipo de datos es obligatorio ponerlo y le dice al compilador cuantas celdillas de memoria tiene que reservar para almacenar el valor de la variable. Los tipos de datos pueden variar de un compilador a otro, vamos a ver los tipos de datos que podemos usar con nuestro compilador CCS.

 Los tipos de datos básicos que utiliza nuestro compilador son los siguientes:

      Sin embargo el compilador CCS también admite los siguientes tipos de datos definidos en el estándar C y que son los que normalmente se utilizan a la hora de programar:

                      Todos los tipos excepto float son por defecto sin signo, aunque pueden llevar el   especificador  unsigned ó signed y su rango de valores será el que corresponda a su  ipo básico.

2.    Elaborar un programa que CUENTE 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. Muestre la simulación de dicho 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

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;

int cuenta=0;

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

// 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(0b000000001);         // activamos display #1

   delay_ms(delay);              // esperamos tiempo para que se muestre dígito

  

   output_b(tabBCD[centenas]);

   output_a(0b00000010);

   delay_ms(delay);

  

   output_b(tabBCD[decenas]);

   output_a(0b00000100);

   delay_ms(delay);

  

   output_b(tabBCD[unidades]);

   output_a(0b00001000);

   delay_ms(delay);

}

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

// FUNCION PRINCIPAL VOID (MAIN)

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

void main ()                    

{

   dato = 0;                  // ingrese numero inicial a visualizar

   visualizar();                 // mostramos el valor de "dato" en displays

  

   while(cuenta<6)

 

   {

      IF (!input(PIN_A5))        // si pulsamos A5.....

      {

         dato = dato + 1;        // el valor "dato" se incrementa en uno

         descomp_entero(dato);   // descomponemos el valor "dato"

         delay_ms(300);          // congelamos el tiempo para evitar falsos disparos

         cuenta=cuenta+1;        // aumentamos en 1 la variable cuenta

         visualizar();

      }

     

   }

   FOR (int i=0;i<=2;++i)                   //Se repetirá 3 veces el sonido BIP

       {

               FOR (int BIP=0;BIP<=20;++BIP)             // Se repetirá 20 veces los comandos siguientes entre llaves

               {

               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

               }

         delay_ms(1000);                      //delay de 1 segundo para espacio entre cada BIP

       }

}

3.    Video mostrando las tareas realizadas en laboratorio.

     Link del video:

        simulación de las tareas realizadas en el laboratorio

4.    Video mostrando en SIMULACION el programa solicitado.

       Link del video: 

        CONTADOR DE 1 A 6 LUEGO SUENA 3 BIPS

Observaciones:

o    Observamos que los 4 display que tenemos en la placa entrenadora de PIC están conectados en forma multiplexada, esto quiere decir que solo tenemos una entrada a un display para activarlo y desactivarlo y las correspondientes entradas para los segmentos.

o   
Observamos que al momento de compilar el programa al microcontrolador, el display mostraba los números : "4 3 2 1", en ese orden, el cual no era correcto, pero al simularlo en proteus el orden de los números, si era el correcto era de : " 1 2 3 4", entonces tuvimos que modificar el orden de las salidas del display en la programación.

o   
 El pin A5 se activa en bajo por lo que necesita entrar un cero lógico al pulsarlo, esto quiere decir configuración pulsador-resistencia pull up.

o    La variable " descomp-entero", hace que el dato se descomponga en 4 números: unidades, decenas, centenas y milésimas.

o    Se había programado a la entrada E2 para que al darle un pulso, disminuyera de 10 en 10. Se cambio para que disminuyera de 5 en 5, cuando a "0" se le restaba 5, el display mostraba un valor de 531 y de este valor empezó a disminuir de 5 en 5.

Conclusiones:

·         Aprendimos que la técnica de multiplexado nos ahorra demasiado cableado hacia los display, así solamente tenemos que pensar en una lógica de programación para poder crear nuestros contadores.

·         Concluimos que las subrutinas nos ayudan bastante a la hora de querer ahorrar líneas de código, solamente basta con llamarlas en la función principal.

·         Es necesario tener un tiempo de retardo (delay) adecuado para no tener inconvenientes al momento de realizar la simulación, ya que se pudo comprobar que al momento de disminuir el tiempo de retardo "delay" a 100ms en las entradas que son los pulsadores, ocurría un rebote al pulsar una entrada, es decir los números contaban muy rápido y no se podia apreciar bien de cuanto en cuanto contaba.

·         El programa que hicimos para contar de 0 a 9999, bota un número que
aparece en todos los display cada vez que presionamos el pulsador pero al tener un retraso de 5 ms el ojo no logra notar esto y notamos como aparecieran varios a la vez.

Realizado por: 

Benito Mendoza Gabriela

Valdivia Apaza Percy