Display de 7 segmentos en arduino: De la programación a pedal a la del motor.

El objetivo de este documento es mostrar al lector la diferencia entre programar un microcontrolador como el del arduino paso a paso, lo cual es mucho más lento y dispendioso,  y luego  elaborar el mismo programa en una forma más rápida y corta, utilizando arreglos y algunas funciones que permiten agilizar el Proceso.

En mi concepto personal de como maestro de Circuitos Digitales mi parecer es que en un principio es conveniente elaborar el programa paso a paso para comprenderlo mejor, incluyendo si lo vemos necesario el diagrama de flujo correspondiente.

Luego de entender con claridad que es lo que  "ESTAMOS HACIENDO" podemos buscar la forma de hacer la tarea en una forma más corta, eficiente y rápida.

Es como la vida misma:  Primero aprendimos a caminar, a usar la  bicicleta y  luego pasamos a la  moto o al  automóvil. El caminar y la bicicleta nos proporciona el ejercicio físico necesario para la salud, pero cuando requerimos realizar una diligencia rápidamente y a un sitio distante, seguramente lo más práctico es utilizar el Automóvil o un vehículo de transporte público.

Vamos a manejar un display  de 7 segmentos, cátodo Común,  miniatura de Referencia SM420561K,  para  ser Implementado en el protoboard.

El display dispone de 7 leds,  para los segmentos a, b, c, d, e, f, g,  tal como se muestra en la figura anterior.  Además dispone de un octavo led  para el punto. La configuracion de pines  también  se indica en  la figura. Existen dos pines para el cátodo común que dęben conectarse a GND (tierra).

 Pretendemos en este proyecto  visualizar en el display  los numeros del 0 al 9, y las letras A, B, C, D, E, F,
del Sistema Numérico Hexadecimal.

 Nosotros conectamos cada ánodo del led en cada segmento  con cables de colores especificos tal como se muestra en el siguiente esquema, disponiendo de una Resistencia de 220 ohmios, 1/4 watio, en serie con cada led, para limitar la corriente y el voltaje en cada led, y  proteger los puertos del Arduino.  La corriente máxima permitida en cada puerto del arduino es de 40 mA. Una corriente mayor quema el puerto.

El Programa de  pedal del  Arduino es el siguiente:

// Visualizacion en display de  7 segmento de los caracteres del Sistema hexadecimal

// Si el carácter es alfabético se enciende el punto decimal

// Los Leds a, b, c, d, e, f, g, y el punto decimal P se encienden al producirse Nivel lógico alto (HIGH) en el pin 

int i;
int j;
int a = 2;
int b = 3;
int c = 4;
int d = 5;
int e = 6;
int f = 7;
int g = 8;
int P = 9;
int retardo = 2000 ;

void setup ()
{
  pinMode (a, OUTPUT);
  pinMode (b, OUTPUT);
  pinMode (c, OUTPUT);
  pinMode (d, OUTPUT);
  pinMode (e, OUTPUT);
  pinMode (f, OUTPUT);
  pinMode (g , OUTPUT);
  pinMode (P, OUTPUT);

  }

 void loop ()
 {
       
    for (i = 0; i <= 15; i ++) 
   { 
     
     if (i == 0) // 0
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a     
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b          
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d          
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e         
     digitalWrite (f, HIGH); // Enciende el SEGMENTO f         
     digitalWrite (g, LOW); // Apaga el SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P  
     delay (retardo);}
                  
    if (i == 1) // 1
     {digitalWrite (a, LOW); // Apaga el SEGMENTO a  
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b        
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, LOW); // Apaga el SEGMENTO d          
     digitalWrite (e, LOW); // Apaga el SEGMENTO e         
     digitalWrite (f, LOW); // Apaga el SEGMENTO f       
     digitalWrite (g, LOW); // Apaga el SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P
      delay(retardo);}
         
     if (i == 2) // 2
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a    
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b         
     digitalWrite (c, LOW); // Apaga el SEGMENTO c         
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d          
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e        
     digitalWrite (f, LOW); // Apaga el SEGMENTO f        
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P
      delay (retardo);}
        
     if (i == 3) // 3
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a    
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b         
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c        
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d          
     digitalWrite (e, LOW); // Apaga el SEGMENTO e       
     digitalWrite (f, LOW); // Apaga el SEGMENTO f       
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P
     delay (retardo);}
          
     if (i == 4) // 4
    {digitalWrite (a, LOW); // Apaga el SEGMENTO a    
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b          
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, LOW); // Apaga el SEGMENTO d         
     digitalWrite (e, LOW); // Apaga el SEGMENTO e         
     digitalWrite (f, HIGH); // Enciende el SEGMENTO f       
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P
     delay (retardo);}
      
     if (i == 5) // 5
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a  
     digitalWrite (b, LOW); // Apaga el SEGMENTO b          
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d          
     digitalWrite (e, LOW); // Apaga el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO f         
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P 
     delay (retardo);}    
       
     if (i == 6) // 6
    {digitalWrite (a, LOW); // Apaga el SEGMENTO a 
     digitalWrite (b, LOW); // Apaga el SEGMENTO b        
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d          
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e         
     digitalWrite (f, HIGH); // Enciende el SEGMENTO f         
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g    
     digitalWrite (P, LOW); // Apaga el punto P
     delay (retardo);}
         
     if (i == 7) // 7
     {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b          
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c         
     digitalWrite (d, LOW); // Apaga el SEGMENTO d         
     digitalWrite (e, LOW); // Apaga el SEGMENTO e         
     digitalWrite (f, LOW); // Apaga el SEGMENTO f       
     digitalWrite (g, LOW); // Apaga el SEGMENTO g     
     digitalWrite (P, LOW); // Apaga el punto P
     delay (retardo);}
   
     if (i == 8) // 8
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a 
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b   
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c    
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, LOW); // Apaga el punto P 
     delay (retardo);}
    
    if (i == 9) // 9
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a  
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b   
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c     
     digitalWrite (d, LOW); // Apaga el SEGMENTO d         
     digitalWrite (e, LOW); // Apaga el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO f         
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g    
     digitalWrite (P, LOW); // Apaga el punto P
     delay (retardo);}
      
     if (i == 10) // A 
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a 
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b   
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c    
     digitalWrite (d, LOW); // Apaga el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P
        delay (retardo);}

     if (i == 11) // B
    {digitalWrite (a, LOW); // Apaga el SEGMENTO a 
     digitalWrite (b, LOW); // Apaga el SEGMENTO b   
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c    
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P
        delay (retardo);}


     if (i == 12) // C
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a  
     digitalWrite (b, LOW); // Apaga el SEGMENTO b   
     digitalWrite (c, LOW); // Apaga el SEGMENTO c    
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, LOW); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P
    delay (retardo);}
     
   
     if (i == 13) // D
    {digitalWrite (a, LOW); // Apaga el SEGMENTO a  
     digitalWrite (b, HIGH); // Enciende el SEGMENTO b   
     digitalWrite (c, HIGH); // Enciende el SEGMENTO c    
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, LOW); // Apaga el SEGMENTO f
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P
       delay (retardo);}

    
     if (i == 14) // E
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO  a 
     digitalWrite (b, LOW); // Apaga el SEGMENTO b   
     digitalWrite (c, LOW); // Apaga el SEGMENTO c    
     digitalWrite (d, HIGH); // Enciende el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P 
       delay (retardo);}

     
    if (i == 15) // F
    {digitalWrite (a, HIGH); // ENCIENDE EL SEGMENTO a  
     digitalWrite (b, LOW); // Apaga el SEGMENTO b   
     digitalWrite (c, LOW); // Apaga el SEGMENTO c    
     digitalWrite (d, LOW); // Apaga el SEGMENTO d   
     digitalWrite (e, HIGH); // Enciende el SEGMENTO e       
     digitalWrite (f, HIGH); // Enciende el SEGMENTO
     digitalWrite (g, HIGH); // ENCIENDE EL SEGMENTO g  
     digitalWrite (P, HIGH); // Enciende el punto P
       delay (retardo);}
               
     }
     }

Veamos una fotografía del montaje realizado:

La alimentación al Arduino UNO  se establece a través de una pila de 9 Voltios recargable, co conector  de 2,1 mm,positivo al centro.

Ahora veamos la programación de motor del arduino, donde se puede observar que el programa es mucho más corto,  utilizando arreglos y funciones tal como se  muestra a continuacion:

// Display 7 segmentos con caracteres en hexadecimal utilizando arreglos y funciones

void setup (){ 
  for (int X = 2; X <= 9; X++)
  pinMode(X,OUTPUT);
}

void loop (){
  int caracter = 0;
  while (caracter <= 15) {
  display7sg(caracter);
  caracter ++;
  delay (3000);
  }
  }

 void display7sg(int num){
 byte
 valores[]={B00111111,B00000110,B01011011,B01001111,B01100110,B01101101,B01111101,B00000111,B01111111,B01101111,B11110111,B11111100,B10111001,B11011110,B11111001,B11110001};
 for (int X = 0; X <= 7; X++) digitalWrite ( X + 2, bitRead(valores[num],X));
 }

Ahora veamos en detalle algunas cuestiones referentes a este programa conciso:

Para la configuracion de pines como salidas  para los ánodos del display de 7 segmentos  utilizamos una función  for.

Inicializamos la X en   2  como un  pin de salida  del arduino donde vamos a conectar el ánodo a   del display.  Los otros pines 3,4,5,6,7,8 y 9  son salidas para los ánodos b, c, d, e, f, g y  p del display de 7 segmentos, cátodo común.

En el bucle principal  del arduino, o sea en  la función Loop ,  debemos desplegar en el display   los 16 caracteres del hexadecimal, desde  el 0 hasta la letra F. Para ello dentro del bucle  usamos la función While. 

Para generar el  dígito  del 0 al 9, o la letra de la A la  F, del caracter hexadecimal, utilizamos ahora la función   display7sg (caracter).

La segmentación de código en funciones permite al programador crear piezas modulares de código que realizan una tarea definida y luego regresan a la zona de código de la que la función fue "Llamada".  El caso típico para la creación de una función es cuando hay que realizar la misma acción varias veces en el  programa.

La función  display7sg (caracter)  que genera cada  uno de los 16 caracteres  para  desplegar en el display está escrita al final, despues de la Función Loop, utilizando Bytes, o sea  grupos de 8 bits,que en este caso son llamados Enteros num. (Números Enteros) . Se Inicia con el 0 hasta llegar al caracter 15, correspondiente en hexadecimal a la letra F.  El bit 0 corresponde al ánodo a del display, y el bit 7 al ánodo del punto. 

Pará estos  16 caracteres de  8 números binarios cada caracter se define un Arreglo llamado Valores [].

Dentro de la función generadora del caracter hexadecimal se encuentra otra función llamada BItRead, que permite desde el 0 hasta la F ir colocando los niveles lógicos altos y bajos adecuadamente  a los pines del arduino, desde el pin 2 para el ánodo a  hasta el pin 9 para el punto.

La Función BitRead Se Puede consultar en la pagina oficial de arduino:

Se puede observar que los bits se van leyendo desde el bit 0 ( el menos significativo)  hasta el bit 7 ( el mas significativo).

Mediante la función for asociada a la bitRead  con  el renglón de código   for (int X = 0; X <= 7; X++) digitalWrite ( X + 2, bitRead(valores[num],X));  cada bit de cada caracter es leido de derecha a izquierda, o sea del menos al más significativo, y sus niveles bajos o altos se llevan a los pines del arduino para apagar o encender los leds del display y desplegar el caracter respectivo.  Como la función es llamada desde el bucle principal al retornar allí, el código del loop mediante la función while se encarga de pasar al siguiente caracter, y vuelve a la función generadora para repetir el proceso.  Cada 3 segundos se irá entonces desplegando cada caracter de forma indefinida.

Una recomendación para mis estudiantes, o el amable lector de este blog:

Esté seguro de comprender cada función. Estudiela acudiendo a la fuente original, o sea a la página oficial del arduino en inglés:

Debe haber comprendido cada función para poderla aplicar dentro de todo un contexto, y lograr ser competente en la programación. Competencia es saber aplicar cada concepto dentro de un contexto.

Lo invito a que repase las funciones For y While:

Para finalizar una frase para que reflexione sobre ella:  "Para comprender a Dios debemos expresar amor, porque Dios es Amor, y sólamente podemos aplicar lo que logremos comprender"  

Cuando se entiende todo lo que hacemos, disfrutamos del conocimiento adquirido y nos apasionamos y alcanzaremos grandes logros.