Electrónica

DISPLAY DE 7 SEGEMENTOS : PROYECTO RELOJ CON PIC16F628.

Posted onAuthormksdgo@gmail.com

Saludos amigos, en esta ocasión compartiré con ustedes la realización del proyecto de un reloj con display de 7 segmentos y PIC16f628. Les mostrare el código en lenguaje C para grabar en el microcontrolador, así como también el diagrama del circuito para que si se animan puedan también ensamblar con éxito su propio reloj.

Comenzaremos con algo de teoría básica.

COMO FUNCIONA UN DISPLAY DE 7 SEGMENTOS.

Un display de 7 segmentos no es mas que un arreglo de leds dispuestos de tal manera que si se activan algunos de ellos por medio de un voltaje pueden mostrar un numero o un caractér.

7-segment display | IoT

Existen displays de 7 segmentos de cátodo común como el de la figura de arriba en donde el display se activa con el terminal común conectado a GND o tierra y también los de ánodo común, donde se activa el display con el terminal común conectado al terminal positivo del circuito.

Para nuestro proyecto usaremos un display de 4 dígitos de ánodo común, como el que te mostramos a continuación. Los dos primeros dígitos serán para mostrar las horas y los 2 últimos para mostrar los minutos.

Galaxy Red 0.39 Inch Segment Display In 4 Digit, Shape: Rectangle, | ID: 7899354348

EL MULTIPLEXADO EN EL DISPLAY DE 7 SEGEMENTOS CONTROLADO CON EL PIC16F628.

El multiplexado es una técnica muy útil que consiste en una activación secuencial de elementos en este caso seria de cada uno de los 4 dígitos de nuestro display para optimizar los recursos de una unidad de control. En este caso la unidad de control seria el PIC y los recursos serian los puertos de entrada y salida que este maneja.

Veamos si no utilizaríamos la técnica de multiplexado si tenemos que cada digito del display esta conformado por 7 leds y tenemos que nuestro reloj maneja 4 dígitos requeriríamos por lo menos 4×7= 28 es decir como mínimo requeriríamos 28 puertos configurados como salidas,

sin embargo nuestro pic al hacer el multiplexado realizara la siguiente secuencia de trabajo en donde mostramos las 12 horas con 13 minutos,

El multiplexado realizara las activaciones de los pasos 1,2,3 y 4 de forma tan rápida que al final para el ojo humano obtendremos una imagen fija como en la ultima imagen.

DISPLAY DE 7 SEGMENTOS CON RESISTENCIAS O SIN RESISTENCIAS.

Cada segmento del display al no ser mas que un simple led posee unas características especificas de voltaje y corriente que puede soportar y eso como siempre depende del color del display.

En el caso del color rojo, cada segmento podrá soportar un promedio de 1,7 voltios y 20 mA

En el caso de aplicar una tensión directa al display para activar los segmentos es indispensable conectar resistencias limitadoras a cada patita del display para asegurar que el led no reciba mas de lo que puede soportar.

Sin embargo, para este proyecto vamos a poder prescindir de este componente aunque parezca algo arriesgado, te explico por que:

Nosotros vamos a utilizar una técnica que se denomina multiplexado para controlar los 4 dígitos de un display de ánodo común,

La técnica de multiplexado consiste en activar y desactivar cada digito del display a una velocidad muy alta, cosa que puede hacer sin ninguna dificultad nuestro PIC16f628 para dar la impresión a la vista de que todos los dígitos están operando al mismo tiempo, En el caso de nuestro reloj, los 2 primeros dígitos del display serán las horas y los 2 últimos serán los minutos.

Es decir los leds de cada digito debido a la técnica de multiplexado estarán encendidos un periodo tan pero tan corto que literalmente no tienen tiempo para quemarse.

Es por ello que el circuito de nuestro proyecto no lleva resistencias limitadoras, sin embargo si te sientes mas seguro puedes colocarlas sin ningún problema.

DISEÑO DEL CIRCUITO DE NUESTRO RELOJ CON DISPLAY DE 7 SEGEMENTOS Y PIC16F628A.

Nuestro circuito del reloj con display de 7 segmentos sera controlado con un microcontrolador PIC16f628A, el cual tiene las entradas y salidas suficientes para controlar sin problemas el display de 4 dígitos, ademas nuestro reloj estará equipado con 2 pulsadores, para configurar tanto los minutos como las horas.

DISPLAY DE 7 SEGMENTOS RELOJ

EL CODIGO DE PROGRAMACION PARA NUESTRO RELOJ CON DISPLAY DE 7 SEGMENTOS Y PIC16F628.

Nuestro PIC utilizara la interrupción del timer1 del PIC16f628 para controlar los segundos, que son la unidad básica de tiempo de nuestro reloj.

Para este proyecto utilizaremos un cristal de cuarzo de 4MHZ y 2 condensadores cerámicos para hacer latir el corazón de nuestro PIC. y esto por que la RC de 4MHZ interna del PIC no tiene precisión para aplicaciones de control de tiempo, nuestro reloj se atrasaría o adelantaría sin control.

Ademas utilizaremos los pines RA4 y RB7 como entradas para conectar nuestros pulsadores, los cuales servirán para configurar las horas y los minutos de nuestro reloj.

A continuación mostramos la parte principal del programa para que puedas revisarla , si deseas descargar el código completo listo para compilar y la simulación en PROTEUS dejare el link al final de la pagina.

void main()
{ 
Ticker = FRECUENCIA_TIMER1;                    //  Frecuencia _Timer1 tiene el valor de 1000000 se carga ticker con ese valor
setup_timer_1( T1_INTERNAL | T1_DIV_BY_1 );    // initializa TIMER1 para interrupción 
enable_interrupts( INT_TIMER1 );               // habilita LA interrupción (CUANDO LLEGA A SU VALOR MAXIMO 65536 ) TIMER1
enable_interrupts(GLOBAL); 
CVRCON=0;                   //DESABILITA EL COMPARADOR ANALOGICO PARA QUE EL PIN A2 SE PUEDA UTILIZAR COMO ENTRADA SALIDA DIGITAL.
CMCON=7;                    //APAGA LOS COMPARADORES PARA QUE LOS PINES RA3 Y RA4 SE PUEDAN UTILIZAR COMO ENTRADAS Y SALIDAS DIGITALES.
TRISA=0B00010000;           // todo el puerto A como salida expeto el PIN RA4 del pulsador
TRISB=0B10000000;           // todo el puerto B como salida exepto el PIN RB7 del pulsador


while(1)
{
//*****************************************************************************************************************************   
   if (input (pin_b7)==1)                    // PULSO 1 DE SETEO DE MINUTOS RELOJ
  { 
    output_b(0b01111111);
    delay_ms(200);                           // ANTIREBOTE
    while (true)                          
   {  
   showminuto();                     
   if (input (pin_a4)==1)           
            {
            delay_ms(200);
            minuto++;
            if(minuto > 59)
            minuto = 0;
            }
//*****************************************************************************************************************************
   if (input (pin_b7)==1)                    // PULSO 2 DE SETEO DE HORAS RELOJ
  { 
    output_b(0b01111111);
    delay_ms(200);                          // ANTIREBOTE
    while (true)                          
   {  
   showhora();                     
   if (input (pin_a4)==1)           
            {
            delay_ms(200);
            hora++;
            if(hora > 23)
            hora = 0;
            }
            
          if(input(pin_b7) == 1)             
            {
             delay_ms(200);                     
             goto salida;                       
            }          
//*****************************************************************************************************************************
   }}}
  }  
//************************************************* FIN DEL IF DE PULSACIONES *************************************************  
  
salida:
display();
}
}


//********************************************* FUNCIONES DEL PROGRAMA ********************************************************

//******************* LIMPIA ES USADO POR EL BOTON DE SETEADO *****************************
void limpia()                   
{
  output_b(0b01111111);
}
void numero(int dato)
{
   switch( (dato))   //   DECENAS
    {         
     case 0:PORTB=0x40;break;     // MUESTRA EL ARREGLO POR EL PUERTO B
     case 1:PORTB=0x79;break;    
     case 2:PORTB=0x24;break;      
     case 3:PORTB=0x30;break;       
     case 4:PORTB=0x19;break;      
     case 5:PORTB=0x12;break;
     case 6:PORTB=0x02;break;
     case 7:PORTB=0x78;break;
     case 8:PORTB=0x00;break;
     case 9:PORTB=0x10;break;
    }
    delay_us(500);               // RETARDO QUE PERMITE QUE SE VISUALICE EL NUMERO EN EL DISPLAY 
    limpia();                    // LIMPIA EL PUERTO B 
}

void clear ()
{
PORTB=0b01111111;                  // ARREGLO QUE APAGA EL CAJON DEL DISPLAY 
delay_us(500);               // espero para que se VEA (en este caso CAJON APAGADO)  
}

void display (void)
{
//*****************************************************************************************************************//
PORTA=0b00000001;
numero(minuto%10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00000010;
numero(minuto/10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00000100;
numero(hora%10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00001000;
numero(hora/10);
delay_us(500);
PORTA=0b00000000;
}

void showminuto()
{
//*****************************************************************************************************************//
PORTA=0b00000001;
numero(minuto%10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//   
PORTA=0b00000010;
numero(minuto/10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00000100;
PORTB=0b01111111;
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00001000;
PORTB=0b01111111;
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
}

void showhora()  
{
//*****************************************************************************************************************//
PORTA=0b00000001;
PORTB=0b01111111;
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//   
PORTA=0b00000010;
PORTB=0b01111111;
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00000100;
numero(hora%10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
PORTA=0b00001000;
numero(hora/10);
delay_us(500);
PORTA=0b00000000;
//*****************************************************************************************************************//
}

Recuerda que una vez compilado el código deberás grabarlo en el PIC con un grabador de microcontroladores.

La programación es muy versátil, puedes agregar si deseas algunas lineas adicionales para configurar también una alarma.

En el protoboard el proyecto puede llegar a tener este aspecto:

DISPLAY DE 7 SEGEMENTOS RELOJ

Ensamblaje del proyecto DISPLAY 7S en cajita de TRIPLAY

Finalmente nosotros decidimos colocar nuestro pequeño reloj dentro de una cajita de madera hecha con nuestra hermosa y versátil CNC.

Nos quedo de lujo verdad ?.

DISPLAY DE 7 SEGMENTOS

Bueno llegamos al fin de este post estimados lectores, continuación les dejo el link para que puedan descargar el código completo listo para compilar, el archivo hex y la simulación en PROTEUS.

LINK ARCHIVOS RELOJ DISPLAY DE 7 SEGEMNETOS

Eso ha sido todo amigos en este post ” RELOJ DISPLAY DE 7 SEGMENTOS CON PIC16F628 ” esperamos que esta información en algún momento te sea de utilidad.

Recuerda que una manera de ayudarnos a mantener este contenido en linea y actualizado es visitando los anuncios que aparecen a lo largo del post. Gracias por tu apoyo!

Recuerda tambien que puedes visitar todo el contenido de nuestro blog en :

BLOG DE TECNOCIENCIA.

https://www.tecnocienciaperu.com/blog/

https://www.youtube.com/c/MarcosAguilar_mks/videos?view_as=subscriber

También puedes visitar nuestro canal de YouTube en :

2 Replies to “DISPLAY DE 7 SEGEMENTOS : PROYECTO RELOJ CON PIC16F628.”

Agregue un comentario

Su dirección de correo no se hará público. Los campos requeridos están marcados *