Display de 7 segmentos con Arduino

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 se dispone de un octavo led para el punto. La configuración de pines se indica también en la figura. Existen dos pines para el cátodo común que debe conectarse a GND (tierra).

El objetivo del presente proyecto es visualizar en el display los números del 0 al 9, y las letras A,B,C.D,E,F,
del sistema numérico  Hexadecimal.

El punto solo enciende con las letras.



En los almacenes especializados, como tienda de Robótica,  donde se suministran accesorios para trabajar con el Arduino venden  cables  de colores, muy útiles para llevar un orden y no confundirnos al  conectar el display a los pines del Arduino.

Nosotros conectamos cada segmento con un cable de color específico tal como se muestra en el siguiente esquema, disponiendo de una resistencia de 220 ohmios, 1/4 watio, en serie con cada diodo led, para limitar  la corriente en cada led y proteger los puertos del Arduino:

El programa en Arduino es el siguiente:


//Visualización en display de 7 segmentos 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 un 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 R3 se establece a través de una pila de 9 voltios recargable, con un plug de 2.1 mm, positivo al centro.
Se puede obtener un programa mucho más corto utilizando arreglos,tal como se muestra a continuación:


// Display de 7 segmentos,catodo común, en hexadecimal usando arreglos

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));
 }

Documental presentado por los creadores del Arduino

La fotografía muestra al equipo creador del Arduino,entre ellos Massimo Banzi (Italiano) y David Cuartielles (Español), sus pioneros.

Presentamos un resumen de la historia de Arduino y cómo se creó este gran proyecto.  La información se ha extraído de la revista IEEE Spectrum:

Veamos algunas ideas principales del texto:

• Arduino nació como un proyecto educativo en el año 2005 .
• Su nombre viene del nombre del bar  Arduino donde Massimo Banzi pasaba algunas horas en Italia, el cual a su vez viene del nombre de un antiguo rey europeo allá por el año 1002.
• Banzi dice que nunca surgió como una idea de negocio, es más nació por una necesidad de subsistir ante el eminente cierre del Instituto de diseño Interactivo IVREA en Italia.  Es decir, al crear un producto open hardware (de uso público) no tendría problemas legales por su uso. 
• A la fecha se han vendido más de 250 mil placas en todo el mundo sin contar las versiones clones y compatibles.
• Para su creación participaron estudiantes que desarrollaban sus tesis como Hernando Barragan (Colombiano) quien desarrolló la plataforma  Wiring con la cual se programa el microcontrolador.
• Hoy en día con Arduino se pueden fabricar infinidad de prototipos y cada vez su uso se viene expandiendo más.  
• Google ha apostado por el proyecto y ha colaborado en el Android ADK (Accesory Development Kit), una placa Arduino capaz de comunicarse directamente con spmartphones Android para obtener las funcionalidades del teléfono (GPS, acelerómetros, GSM, bases de datos) y viceversa para que el teléfono controle luces, motores y sensores conectados de Arduino.
• El primer prototipo fue desarrollado en el instituto IVRAE pero aún no se llamaba Arduino, lo que se muestra en la siguiente fotografía.  
• 

• Para la producción en serie de la primera versión se tomaron en cuenta algunas consideraciones: De bajo precio, debía ser Plug and Play, utilizaron el color azul para marcar una diferencia con las placas convencionales, trabajar en todas las plataformas (Mac, Windows y Linux).
• La primera producción fue de 300 unidades y se las dieron a los alumnos del Instituto IVRAE, (las ganancias fueron de sólo 1 Euro por placa), con el fin de que las probaran y empezaran a diseñar sus primeros prototipos.
• Uno de los primeros proyectos fue un reloj alarma, el cual no se apagaría hasta que no te pararas de la cama.
• Tom Igoe, profesor y padre de la computación física se unió al proyecto luego que se enterara del mismo a través de la web.  El ofreció su apoyo para desarrollar el proyecto a grandes escalas.
• Hoy por hoy Arduino te permite crear cosas por ti mismo.
• Varias universidades como Standford y Carnegie Mellon y el MIT usan Arduino en sus campus.

Les recomendamos ver el video del documental Arduino Español (28 min), dando click a continuación:

Documental sobre Arduino

Simulador para el Arduino: virtualbreadboard

Los invito a observar el interesante video tutorial de un simulador para el Arduino que encontré de un Instituto Tecnologico en Bolivia:  http://youtu.be/TfemwzKfKrc

Este tutorial está dirigido a principiantes sin conocimientos previos de la plataforma Arduino que desean aprender el lenguaje de programación con la ayuda de un simulador.

Para más tutoriales similares ingresar a http://www.TecBolivia.com

NOTA: Hasta mediados del año 2011 el software "VirtualBreadboard" estaba disponible como descarga gratuita, por decisión de su desarrollador actualmente la licencia tiene un costo mínimo. Para más detalles ingresar a su sitio web en www.virtualbreadboard.com/