Manejo display 7 segmentos empleando Arduino

Nuestro objetivo es implementar un programa que pueda convertir de binario a sus respectivos caracteres en los sistemas decimal, hexadecimal, octal y base 5. Dichos caracteres serán mostrados en un display de 7 segmentos con ánodo común.

El programa cumplirá los siguientes requisitos 

• En caso de que este en modo HEXADECIMAL, se debe implementar la siguiente tabla de caracteres.

• Para el modo BCD, cuando los valores binarios son mayores que nueve (9), el display deberá apagarse. 
• En el modo OCTAL, todo valor binario mayor que siete (7) se debe reemplazar por el pictograma.
• En el modo base 5, si la entrada es mayor que o igual a cinco (5) y menor o igual a diez (10), el display debe permanecer apagado; cuando la entrada es mayor a diez (10), mostrará el pictograma.

Pictograma

Montaje

Las resistencias utilizadas son de 330Ω. La siguiente tabla hace relación a las conexiones de los pines de salida con cada segmento del display.

Segmento	Color	Pines salida
a		0
b		1
c		2
d		3
e		4
f		5
g		6

Para la selección del sistema de conversión y para la entrada binaria de 4 bits, se utilizará un dipswitch. 

El pin 0 y 1 del dipswitch son para seleccionar el sistema que deseamos realizar la conversión. Para esto utilizamos la siguiente combinación:

Pin0	Pin1	Conversión
0	0	Binario a base 5
0	1	Binario a octal
1	0	Binario a decimal
1	1	Binario a hexadecimal

Tener en cuenta que las entradas del Arduino serán configuradas como INPUT_PULLUP, esto significa que los pines tendrán una configuración inicial a nivel alto. Sino sabes de qué se trata, puedes observar la siguiente imagen donde te muestro dicha configuración:

Para más información sobre esta configuración en Arduino puedes visitar su página oficial.

Lo anterior significa que cuando el dipswitch se accione, los pines del Arduino estarán en un nivel bajo. Para la lógica que vamos a manejar en el programa, vamos a ser de cuenta que cuando se accione, la lectura sea un nivel alto. Esta lógica la vamos a invertir con un pequeño truco que les muestro en el código.

Código

/*

Manejo de un display de 7 segmentos utilizando el acceso al puerto D medianteregistros
Conecte los sigueintes pines de Arduino al segmento que aparece en frente
PIN0 a
PIN1 b
PIN2 c
PIN3 d
PIN4 e
PIN5 f
PIN6 g

*/
int var = 0; //Variable donde se guarda la entrada binaria
#define ANODO_COMUN //Definimos display ánodo común

/*Salida para DECIMAL*/
const unsigned char tabla_BCD[16] = {
  B01000000, //0
  B01111001, //1
  B00100100, //2
  B00110000, //3
  B00011001, //4
  B00010010, //5
  B00000010, //6
  B01111000, //7
  B00000000, //8
  B00010000, //9
  B01111111, //10
  B01111111, //11
  B01111111, //12
  B01111111, //13
  B01111111, //14
  B01111111 //15
};

/*Salida para base 5*/
const unsigned char tabla_base5[16] = {
  B01000000, //0
  B01111001, //1
  B00100100, //2
  B00110000, //3
  B00011001, //4
  B01111111, //5
  B01111111,//6
  B01111111, //7
  B01111111, //8
  B01111111, //9
  B01111111, //10
  B00011000, //11
  B00011000, //12
  B00011000, //13
  B00011000, //14
  B00011000 //15
};

/*Salida paraOCTAL*/
const unsigned char tabla_octal[16] = {
  B01000000, //0
  B01111001, //1
  B00100100, //2
  B00110000, //3
  B00011001, //4
  B00010010, //5
  B00000010, //6
  B01111000, //7
  B00011000, //8
  B00011000, //9
  B00011000, //10
  B00011000, //11
  B00011000, //12
  B00011000, //13
  B00011000, //14
  B00011000 //15
};

/*Salida para HEXADECIMAL*/
const unsigned char tabla_HEX[16] = {
  B01000000, //0
  B01111001, //1
  B00100100, //2
  B00110000, //3
  B00011001, //4
  B00010010, //5
  B00000010, //6
  B01111000, //7
  B00000000, //8
  B00010000, //9
  B00001000, //A
  B00000011, //b
  B01000110, //C
  B00100001, //d
  B00000110, //E
  B00001110 //F
};

unsigned char sel = 0;

void setup() {
  pinMode(A0, INPUT_PULLUP);
  pinMode(A1, INPUT_PULLUP);
  pinMode(A2, INPUT_PULLUP);
  pinMode(A3, INPUT_PULLUP);
  pinMode(A4, INPUT_PULLUP);
  pinMode(A5, INPUT_PULLUP);
  DDRD = 0XFF; //Puerto D del Arduino como salida
}

void loop() {
  /*Invertimos lógica entradas*/

  /*Pines de selección sistema de conversión*/
  bool s1 = !digitalRead(A0);
  bool s2 = !digitalRead(A1);

  /*Entradas binarias*/
  bool x = !digitalRead(A2);
  bool y = !digitalRead(A3);
  bool z = !digitalRead(A4);
  bool w = !digitalRead(A5);

  /*Se guarda la entrada binaria en su respectivo orden xyzw vriable tipo entera*/
  var = x<<3;
  var|= y<<2;
  var|= z<<1;
  var|= w<<0;
  
  /*Modo base 5*/
  if(!s1&&!s2){
    #ifdef ANODO_COMUN
    PORTD = tabla_base5[var];
    #endif
  }
  /*Modo base octal*/
  else if(!s1&&s2){
    #ifdef ANODO_COMUN
    PORTD = tabla_octal[var];
    #endif
  }
  else if(s1&&!s2){
    #ifdef ANODO_COMUN
    PORTD = tabla_BCD[var];
    #endif
  }else{
    #ifdef ANODO_COMUN
    PORTD = tabla_HEX[var];
    #endif
  }
}

Se puede observar que los arreglos para cada sistema numérico están configurados como Bxxxxxxxx en cada posición. Los ceros(0) nos indica que el segmento estará encendido y los unos (1) apagado. Para explicar tomaremos el ejemplo del arreglo tabla_BCD en las posiciones cero (0) y siete (7), respectivamente:

B01000000. Este código deberá encender el carácter cero (0) en el display activando todo el puerto D del arduino (Pines 0-7) en el siguiente orden: 

Pin salida	Estado
0	0
1	0
2	0
3	0
4	0
5	0
6	1
7	0

B01111000. Este código deberá encender el carácter siete (7) en el display activando todo el puerto D del arduino (Pines 0-7) en el siguiente orden:

Pin salida	Estado
0	0
1	0
2	0
3	1
4	1
5	1
6	1
7	0

Si tienes alguna pregunta no dudes en hacerla, trataré de solucionarla a la brevedad.