Electrónica•Ingenia

Electrónica•Ingenia
sábado, 14 de abril de 2012

Tema 2.- Gestión de los puertos (IV)

Controlando un Display de 7 Segmentos.



El display 7 seg. es un dispositivo usado para presentar información de forma visual. Esta información es específicamente un dígito decimal del 0 a 9, en formato decimal, o de 0 a F, en formato hexadecimal. El display está formado por un 7 Leds, uno por cada segmento, y otro para señalar un punto. Los segmentos se encenderán o apagarán dependiendo de la información que se les envíe.
Cada segmento tiene asignado una letra y según en la manera en la que están los Leds conectados el display será de Ánodo común o de Cátodo común.



Sabiendo esto es muy fácil mostrar el número que queramos en el display. Conectado cada segmento a un PIN del puerto B del PIC sólo tendríamos que seguir la siguiente secuencia para encender cada dígito. 
1
2
3
4
5
6
7
8
9


Pues veamos como manejar el display 7 seg. en C con CCS Compiler. En el ejercicio 7 hacemos lo mismo que está en la tabla superior. Es un contador de 0-9, cada segundo se suma un dígito y cuando se llega a 9 se vuelve a empezar desde 0.
//////////////////////////////////////////////////////////////////////
//   _____               _   _     _ ____          _                //
//  |   __|___ _____ ___| |_|_|___| |    \ ___ ___|_|___ ___ ___    //
//  |__   | .'|     |_ -|   | | -_| |  |  | -_|_ -| | . |   |_ -|   //
//  |_____|__,|_|_|_|___|_|_|_|___|_|____/|___|___|_|_  |_|_|___|   //
//                                                  |___|           //
//                                                                  //
//  FIRMWARE:    Ejemplo 7            MICROCONTROLADOR: PIC16F88    //
//                                                                  //
//  WEB:  www.samshieldesigns.blogspot.com                          //
//  COMPILADOR:  CCS C Compiler v.4124                              //
//  IDE:   MPLAB IDE v.8.84                                         //
//  DESCRIPCION: 7seg. Contador 0-9 por el 7seg cada segundo de     // 
//  manera infinita.                                                //
//                                                                  //
//////////////////////////////////////////////////////////////////////
#include <16f88.h>
//////////////////////////////////////////////////////////////////////
//                       CONFIGURACION DEL PIC                      //
//////////////////////////////////////////////////////////////////////
#FUSES HS              // High speed Osc (> 4mhz for PCM/PCH) (>10mhz
                       // for PCD)
#FUSES MCLR            // Master Clear pin enabled
#FUSES NOBROWNOUT      // No brownout reset
#FUSES NOLVP           // No low voltage prgming, B3(PIC16) or B5
                       // (PIC18)used for I/O
#FUSES NOCPD           // No EE protection
#FUSES NOPUT           // No Power Up Timer
#FUSES NOPROTECT       // Code not protected from reading
#FUSES NOWDT           // No Watch Dog Timer
#USE delay(clock=20000000)     // Frecuencia de 20Mhz
#USE standard_io(A)    // Configuramos el PORTA
#USE standard_io(B)    // Configuramos el PORTB
#DEFINE retardo 500    // Retardo de 500ms
//////////////////////////////////////////////////////////////////////
//                     CUERPO PRINCIAPAL FIRMWARE                   //
//////////////////////////////////////////////////////////////////////
void main()
  {
  disable_interrupts(GLOBAL);       // Desactivamos las interrupciones
  while(true)                       // Bucle infinito. True = 1
    {
    output_b(0b00111111);   delay_ms(retardo*2);  // 0
    output_b(0b00000110);   delay_ms(retardo*2);  // 1
    output_b(0b01011011);   delay_ms(retardo*2)   // 2
    output_b(0b01001111);   delay_ms(retardo*2);  // 3
    output_b(0b01100110);   delay_ms(retardo*2);  // 4
    output_b(0b01101101);   delay_ms(retardo*2);  // 5
    output_b(0b01111101);   delay_ms(retardo*2);  // 6
    output_b(0b00000111);   delay_ms(retardo*2);  // 7
    output_b(0b01111111);   delay_ms(retardo*2);  // 8        
    output_b(0b01101111);   delay_ms(retardo*2);  // 9      
    } // End while(TRUE)
  } //Fin void main

Descargar código y .hex:


En el ejercicio 8 hacemos lo mismo pero en este caso utilizamos una matriz y un bucle For. Es más fácil de comprender y por supuesto más fácil a la hora de escribir el código

//////////////////////////////////////////////////////////////////////
//   _____               _   _     _ ____          _                //
//  |   __|___ _____ ___| |_|_|___| |    \ ___ ___|_|___ ___ ___    //
//  |__   | .'|     |_ -|   | | -_| |  |  | -_|_ -| | . |   |_ -|   //
//  |_____|__,|_|_|_|___|_|_|_|___|_|____/|___|___|_|_  |_|_|___|   //
//                                                  |___|           //
//                                                                  //
//  FIRMWARE:    Ejemplo 8            MICROCONTROLADOR: PIC16F88    //
//                                                                  //
//  WEB:  www.samshieldesigns.blogspot.com                          //
//  COMPILADOR:  CCS C Compiler v.4124                              //
//  IDE:   MPLAB IDE v.8.84                                         //
//  DESCRIPCION: 7seg. Contador 0-9 por el 7seg cada segundo de     // 
//  manera infinita, utilizando una matriz.                         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
#include <16f88.h>
//////////////////////////////////////////////////////////////////////
//                       CONFIGURACION DEL PIC                      //
//////////////////////////////////////////////////////////////////////
#FUSES HS              // High speed Osc (> 4mhz for PCM/PCH) (>10mhz
                       // for PCD)
#FUSES MCLR            // Master Clear pin enabled
#FUSES NOBROWNOUT      // No brownout reset
#FUSES NOLVP           // No low voltage prgming, B3(PIC16) or B5
                       // (PIC18)used for I/O
#FUSES NOCPD           // No EE protection
#FUSES NOPUT           // No Power Up Timer
#FUSES NOPROTECT       // Code not protected from reading
#FUSES NOWDT           // No Watch Dog Timer
#USE delay(clock=20000000)     // Frecuencia de 20Mhz
#USE standard_io(A)    // Configuramos el PORTA
#USE standard_io(B)    // Configuramos el PORTB
#DEFINE retardo 500    // Retardo de 500ms
//////////////////////////////////////////////////////////////////////
//                     CUERPO PRINCIAPAL FIRMWARE                   //
//////////////////////////////////////////////////////////////////////
void main()
  {
  disable_interrupts(GLOBAL);      // Desactivamos las interrupciones
  int x;
  int matriz7seg[10]={0b00111111,  // 0. Tambien se puede poner los 
                      0b00000110,  // n meros en hex en vez de binario
                      0x5B, 0x4F,
                      0x66, 0x6D,
                      0x7D, 0x07,
                      0x7F, 0x6F};
  while(true)                      // Bucle infinito. True = 1
    {
    for(x=0;x<10;x++)
        {
        output_b(matriz7seg[x]);
        delay_ms(retardo*2);
        }   
    } // End while(TRUE)
  } //Fin void main
Descargar código y .hex:
Ahora os muestro un vídeo del los ejercicios anteriores. 
Este es el entrenador para PICs de 18 pines.
La manera natural de manejar un display con un microcontrolador es usando un circuito Decodificador BCD a 7 segmentos, como es el 74LS47. El 74LS47 transforma el código binario BCD en el código de 7 segmentos. De esta manera solo utilizamos 4 pines del PIC en vez de 8 como hemos estado haciendo hasta ahora.
Tabla código BCD y lo que corresponde en el display.
Conexión del 74LS47 al display.
Y aquí un ejemplo de programa manejando el display con el decodificador 74LS47. Se puede observar en la matriz que los valores de la misma son iguales a la tabla que está sobre estas líneas.
//////////////////////////////////////////////////////////////////////
//   _____               _   _     _ ____          _                //
//  |   __|___ _____ ___| |_|_|___| |    \ ___ ___|_|___ ___ ___    //
//  |__   | .'|     |_ -|   | | -_| |  |  | -_|_ -| | . |   |_ -|   //
//  |_____|__,|_|_|_|___|_|_|_|___|_|____/|___|___|_|_  |_|_|___|   //
//                                                  |___|           //
//                                                                  //
//  FIRMWARE:    Ejemplo 9            MICROCONTROLADOR: PIC16F88    //
//                                                                  //
//  WEB:  www.samshieldesigns.blogspot.com                          //
//  COMPILADOR:  CCS C Compiler v.4124                              //
//  IDE:   MPLAB IDE v.8.84                                         //
//  DESCRIPCION: 7seg. Contador 0-9 por el 7seg cada segundo de     // 
//  manera infinita, ahorrando 4 pines.                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
#include <16f88.h>
//////////////////////////////////////////////////////////////////////
//                       CONFIGURACION DEL PIC                      //
//////////////////////////////////////////////////////////////////////
#FUSES HS              // High speed Osc (> 4mhz for PCM/PCH) (>10mhz
                       // for PCD)
#FUSES MCLR            // Master Clear pin enabled
#FUSES NOBROWNOUT      // No brownout reset
#FUSES NOLVP           // No low voltage prgming, B3(PIC16) or B5
                       // (PIC18)used for I/O
#FUSES NOCPD           // No EE protection
#FUSES NOPUT           // No Power Up Timer
#FUSES NOPROTECT       // Code not protected from reading
#FUSES NOWDT           // No Watch Dog Timer
#USE delay(clock=20000000)     // Frecuencia de 20Mhz
#USE standard_io(A)    // Configuramos el PORTA
#USE standard_io(B)    // Configuramos el PORTB
#DEFINE retardo 500    // Retardo de 500ms
//////////////////////////////////////////////////////////////////////
//                     CUERPO PRINCIAPAL FIRMWARE                   //
//////////////////////////////////////////////////////////////////////
void main()
  {
  port_b_pullups(true);
  disable_interrupts(GLOBAL);      // Desactivamos las interrupciones
  int x;
  int BCD7seg[10]={0b0000,0b0001,0b0010,0b0011,0b0100,
                   0b0101,0b0110,0b0111,0b1000,0b1001};
  while(true)                      // Bucle infinito. True = 1
    {
    for(x=0;x<10;x++)
        {
        output_b(BCD7seg[x]);
        delay_ms(retardo*2);
        }   
    } // End while(TRUE)
  } //Fin void main
Descargar código y .hex:
Ahora os muestro un vídeo del ejercicio 9. 
Placa entrenadora en fase de pruebas
Ejemplo 10: Otro ejemplo de programa manejando el display con el decodificador 74LS47 pero añadiendo un pulsador para decrementar y otro incrementar. 
Ejemplo 10. 
//////////////////////////////////////////////////////////////////////
//   _____               _   _     _ ____          _                //
//  |   __|___ _____ ___| |_|_|___| |    \ ___ ___|_|___ ___ ___    //
//  |__   | .'|     |_ -|   | | -_| |  |  | -_|_ -| | . |   |_ -|   //
//  |_____|__,|_|_|_|___|_|_|_|___|_|____/|___|___|_|_  |_|_|___|   //
//                                                  |___|           //
//                                                                  //
//  FIRMWARE:    Ejemplo 10           MICROCONTROLADOR: PIC16F88    //
//                                                                  //
//  WEB:  www.samshieldesigns.blogspot.com                          //
//  COMPILADOR:  CCS C Compiler v4.140                              //
//  IDE:   MPLAB IDE v.8.84                                         //
//  DESCRIPCION: 7seg. Contador 0-9 por el 7seg incrementa y        //
//  decrementa pulsando RA0 y RA1. Utilizando el 74ls47.            //
//                                                                  //
//////////////////////////////////////////////////////////////////////

#include <16f88.h>
//////////////////////////////////////////////////////////////////////
//                       CONFIGURACION DEL PIC                      //
//////////////////////////////////////////////////////////////////////
#FUSES HS              // High speed Osc (> 4mhz for PCM/PCH) (>10mhz
                       // for PCD)
#FUSES MCLR            // Master Clear pin enabled
#FUSES NOBROWNOUT      // No brownout reset
#FUSES NOLVP           // No low voltage prgming, B3(PIC16) or B5
                       // (PIC18)used for I/O
#FUSES NOCPD           // No EE protection
#FUSES NOPUT           // No Power Up Timer
#FUSES NOPROTECT       // Code not protected from reading
#FUSES NOWDT           // No Watch Dog Timer
#USE delay(clock=20000000)     // Frecuencia de 20Mhz
#USE standard_io(A)    // Configuramos el PORTA
#USE standard_io(B)    // Configuramos el PORTB
#DEFINE retardo 250    // Retardo de 250ms
//////////////////////////////////////////////////////////////////////
//                     CUERPO PRINCIAPAL FIRMWARE                   //
//////////////////////////////////////////////////////////////////////
void main()
  {
  port_b_pullups(true);
  disable_interrupts(GLOBAL);      // Desactivamos las interrupciones
  int x=5;
  int BCD7seg[10]={0b0000,0b0001,0b0010,0b0011,0b0100,
                   0b0101,0b0110,0b0111,0b1000,0b1001};
  output_b(BCD7seg[x]);         // Muestro el n 5 en el Display
                                // para que mientras que no pulse nada este el 
                                // display mostrando el valor de "x"
  while(true)                   // Bucle infinito. True = 1
    {
    if(input(PIN_A0) == 1){     // Es RA0 es igual a "1"????
        delay_ms(retardo);      // Antirrebote
        x++;                    // Sumo 1 a "X"
        if(x>9)                 // Si x es superior a nueve
           x=0;                 // x pasar  a ser cero.
        output_b(BCD7seg[x]);   // Muestro el n  en el Display
        }
    
    if(input(PIN_A1) == 1){     // Es RA1 es igual a "1"????
        delay_ms(retardo);      // Antirrebote
        x--;                    // resto 1 a "X"
        if(x==255)              // Si x es inferior a cero o lo que es lo mismo 
                                // 255 (va de 0-255)
           x=9;                 // x pasar  a ser nueve.
        output_b(BCD7seg[x]);   // Muestro el n  en el Display
        }
    } // End while(TRUE)
  } //Fin void main
Descargar código y .hex:
En la siguiente entrada del Blog aprenderemos a multiplexar varios displays para mostrar números de más de un dígito e incluso mostrar mensajes.
Estad atentos!!! ;)
Share this post
  • Share to Facebook
  • Share to Twitter
  • Share to Google+
  • Share to Stumble Upon
  • Share to Evernote
  • Share to Blogger
  • Share to Email
  • Share to Yahoo Messenger
  • More...

6 comentarios:

  1. Muy bien detallado amigos, saludos

    ResponderEliminar
    Respuestas
    1. Gracias! mi intención es que todo lo expuesto aquí sea fácilmente comprensible y que se aprenda el funcionamiento partiendo de la teoría para más tarde apoyar esos conocimientos en la práctica.

      Eliminar
  2. hola no se si meprodrias ayudar por que necesito ejercicio 9 pero con 4 display

    ResponderEliminar
  3. Grcias esta bien pero me podrias ayudar como el ejercici 9 pero con cuatro display

    ResponderEliminar
  4. hola en el ejemplo 8 , por que lo llamas matriz? si es un vector saludos.

    ResponderEliminar
    Respuestas
    1. Hola Anónimo, pues yo en su momento las estudie como matrices. Es más como matrices multidimensionales.

      Eliminar