DISPLAY DE 7, 14 SEGMENTOS

El display de 7 segmentos tiene una estructura casi estándar en cuanto al nombre de los
segmentos. Para dicho elemento, se cuenta con 7 leds, uno para cada segmento. Para cada
segmento, se le asigna una letra desde la «a» hasta la «g». El display tiene por nombre a cada
uno de los siguientes segmentos, es decir, el símbolo del display 7 segmentos es:

Tipos de display 7 segmentos

Existen dos tipos principales para los display 7 segmentos. Esta diferencia depende
principalmente del arreglo como están conectados los leds que forman a cada segmento.
Sabemos que un led tiene dos terminales que se denominan: cátodo y ánodo. El ánodo es la parte
positiva del LED, mientras que el cátodo es el pin negativo. Entonces los tipos de display de 7
segmentos se dividen en aquellos de cátodo común y los de ánodo común. Entonces el display
tendrá además de los 7 segmentos, 1 pin común. Este pin común se conecta al catodo o al anodo
dependiendo del tipo de display.

Display 7 segmentos cátodo común

El display cátodo común es aquel que tiene el pin común conectado a los negativos de los LED’s
(cátodo). Esto significa que este tipo de display se «controla» con ‘1’ s lógicos o con voltaje
positivo. El arreglo para un display de cátodo común seria el siguiente:
Display 7 segmentos ánodo común
El display ánodo común es aquel cuyos ánodos están conectados al mismo punto. Este tipo de
display es controlado por ceros, es decir que el microcontrolador o MCU, FPGA o
microprocesador, le asigna a cada segmento un cero lógico (también llamada tierra digital). El
esquema o diagrama del display de 7 segmentos en ánodo común es:

Funcionamiento del display de 7 segmentos

El display de 7 segmentos funciona al activar y desactivar cada uno de los leds para formar los
números deseados. Por ejemplo, en la siguiente imagen te mostramos como debe de ser la
activación de cada segmento para representar los números 0 y 3.
CIRCUITO DE 1 DÍGITO.

El circuito de montaje de encendido de un dígito, es muy simple se muestra a continuación y

debajo el código.

El código es igual de sencillo, se ha incluido el Dp (pin digital point), por ese motivo se ha
añadido la octava resistencia. La secuencia enciende y apaga cada segmento y luego una
secuencia de los 7 al tiempo. Por cierto, el display es un ánodo común FND507 que tenía a
mano.

Encendido de 7 segmentos.
1 // Creado por V. García 26.02.2014
2 //
3 // definimos los 7 segmentos y los asignamos a los pines
4 int A = 2;
5 int B = 3;
6 int C = 4;
7 int D = 5;
8 int E = 6;
9 int F = 7;
10 int G = 8;
11 int Dp = 9;
12
13 // Configuramos los pines.
14 void setup() {
15 pinMode (A, OUTPUT);
16 pinMode (B, OUTPUT);
17 pinMode (C, OUTPUT);
18 pinMode (D, OUTPUT);
19 pinMode (E, OUTPUT);
20 pinMode (G, OUTPUT);
21 pinMode (F, OUTPUT);
22 pinMode (Dp, OUTPUT);
23 }
24
25 // Y encendemos los segmentos.
26 void loop() {
27 digitalWrite(A, HIGH);
28 delay(300);
29 digitalWrite(A, LOW);
30 delay(300);
31 digitalWrite(B, HIGH);
32 delay(300);
33 digitalWrite(B, LOW);
34 delay(300);
35 digitalWrite(C, HIGH);
36 delay(300);
37 digitalWrite(C, LOW);
38 delay(300);
39 digitalWrite(D, HIGH);
40 delay(300);
41 digitalWrite(D, LOW);
42 delay(300);
43 digitalWrite(E, HIGH);
44 delay(300);
45 digitalWrite(E, LOW);
46 delay(300);
47 digitalWrite(F, HIGH);
48 delay(300);
49 digitalWrite(F, LOW);
50 delay(300);
51 digitalWrite(G, HIGH);
52 delay(300);
53 digitalWrite(G, LOW);
54 delay(300);
55 digitalWrite(Dp, HIGH);
56 delay(300);
57 digitalWrite(Dp, LOW);
58 delay(600);
59
60 digitalWrite(A, HIGH);
61 digitalWrite(B, HIGH);
62 digitalWrite(C, HIGH);
63 digitalWrite(D, HIGH);
64 digitalWrite(E, HIGH);
65 digitalWrite(F, HIGH);
66 digitalWrite(G, HIGH);
67 delay(600);
68 digitalWrite(A, LOW);
69 digitalWrite(B, LOW);
70 digitalWrite(C, LOW);
71 digitalWrite(D, LOW);
72 digitalWrite(E, LOW);
73 digitalWrite(F, LOW);
74 digitalWrite(G, LOW);
75 delay(600);
76 }

CIRCUITO DE 2 DÍGITOS.

El circuito se muestra a continuación. Es muy sencillo y no creo necesario entrar a describir

cada componente. Dos apuntes importantes:

▪ Este mismo circuito, con sólo añadir unas resistencias, nos sirve, para el resto de ejemplos
que se describen.
▪ Los pines analógicos del Arduino (A0…A6), pueden tomarse como digitales, siguiendo el
orden, A0 = A14; A1 = A15; … A6 = A19.
Display de 7 segmentos. Contador con botón.

- Dejamos el dedo pulsando el Botón y el circuito contará de 0 a 9 y luego de 9 a 0, continuará

contando hasta que dejemos de pulsar.
/*
Juan A. Villalpando
kio4.com
agosto 2015
*/

/* Cuenta con Display de 7 segmento de Ánodo común.

*/
#define pin12 12 // Al terminal 12 lo llamamos pin12. Aquí irá el
pulsador.

#define a 2
#define b 3
#define z 4 // He utilizado la z en vez de la c. La c da error.
#define d 5
#define e 6
#define f 7
#define g 8

int contador=0; // Variable contador igual a cero

int lee;
int s=1;

// En el setup establecemos los parámetros iniciales.

void setup() {
pinMode(pin12, INPUT); // El pin12 será entrada. Pulsador.

pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(z, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);

Serial.begin(9600);
}

void loop() {
lee = digitalRead(pin12); // Lee el pin12 y se lo asigna a lee.
(Puede ser 0 o 1)

if (lee == HIGH) {

contador = contador + s;
Serial.print(contador);
if (contador > 9) { s = -1; }
if (contador < 0) { s = 1; }

if (contador == 0) { cero();}
if (contador == 1) { uno();}
if (contador == 2) { dos();}
if (contador == 3) { tres();}
if (contador == 4) { cuatro();}
if (contador == 5) { cinco();}
if (contador == 6) { seis();}
if (contador == 7) { siete();}
if (contador == 8) { ocho();}
if (contador == 9) { nueve();}
}

delay(500);
}

///////////////////////////////////////
void borrado(){
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(z,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
}
void uno(){
borrado();
digitalWrite(b,LOW);
digitalWrite(z,LOW);
}

void dos(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(g,LOW);
digitalWrite(e,LOW);
digitalWrite(d,LOW);
}

void tres(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(g,LOW);
digitalWrite(z,LOW);
digitalWrite(d,LOW);
}

void cuatro(){
borrado();
digitalWrite(b,LOW);
digitalWrite(z,LOW);
digitalWrite(g,LOW);
digitalWrite(f,LOW);
}

void cinco(){
borrado();
digitalWrite(a,LOW);
digitalWrite(z,LOW);
digitalWrite(d,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}

void seis(){
borrado();
digitalWrite(a,LOW);
digitalWrite(z,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}

void siete(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(z,LOW);
}

void ocho(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(z,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}

void nueve(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(z,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}

void cero(){
borrado();
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(z,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
}
Display de 4 digitos.

const char digitos[10] = {

//pgfedcba
0b00111111, //0
0b00000110, //1
0b01011011, //2
0b01001111, //3
0b01100110, //4
0b01101101, //5
0b01111101, //6
0b00000111, //7
0b01111111, //8
0b01101111 //9
};

#define TIME_REBOTE 100

int p1 = 14, p2 = 15, p3 = 16, p4 = 17;
int a = 6, f = 7, b = 8, e = 9, d = 10, dp = 11, c = 12, g = 13;
int d1 = 2, d2 = 3, d3 = 4, d4 = 5;
int var[4] = {0};
int rebote1, rebote2, rebote3, rebote4;

void setup() {
pinMode(p1, INPUT_PULLUP);
pinMode(p2, INPUT_PULLUP);
pinMode(p3, INPUT_PULLUP);
pinMode(p4, INPUT_PULLUP);

pinMode(d1, OUTPUT);
pinMode(d2, OUTPUT);
pinMode(d3, OUTPUT);
 pinMode(d4, OUTPUT);

pinMode(a, OUTPUT);
pinMode(f, OUTPUT);
pinMode(b, OUTPUT);
pinMode(e, OUTPUT);
pinMode(d, OUTPUT);
pinMode(dp, OUTPUT);
pinMode(c, OUTPUT);
pinMode(g, OUTPUT);
}

void loop() {

display_run();

pulsadores();

delay(1);
}

void pulsadores(void) {
if (!digitalRead(p4)) {
if (++rebote1 > TIME_REBOTE) {
rebote1 = 0;
if (++var[0] > 9) {
var[0] = 0;
}
}
} else {
rebote1 = 0;
}

if (!digitalRead(p3)) {
if (++rebote2 > TIME_REBOTE) {
rebote2 = 0;
if (++var[1] > 9) {
var[1] = 0;
}
}
} else {
rebote2 = 0;
}

if (!digitalRead(p2)) {
if (++rebote3 > TIME_REBOTE) {
rebote3 = 0;
if (++var[2] > 9) {
var[2] = 0;
 }
}
} else {
rebote3 = 0;
}

if (!digitalRead(p1)) {
if (++rebote4 > TIME_REBOTE) {
rebote4 = 0;
if (++var[3] > 9) {
var[3] = 0;
}
}
} else {
rebote4 = 0;
}
}

void display_run(void) {
static int contador = 1;
display_write(var[contador - 1], contador);
if (++contador > 4) {
contador = 1;
}
}

void display_write(int dato, int digito) {

digitalWrite(d1, LOW);
digitalWrite(d2, LOW);
digitalWrite(d3, LOW);
digitalWrite(d4, LOW);
if (digitos[dato] & (0x01)) {
digitalWrite(a, HIGH);
} else {
digitalWrite(a, LOW);
}
if (digitos[dato] & (0x02)) {
digitalWrite(b, HIGH);
} else {
digitalWrite(b, LOW);
}
if (digitos[dato] & (0x04)) {
digitalWrite(c, HIGH);
} else {
digitalWrite(c, LOW);
}
if (digitos[dato] & (0x08)) {
digitalWrite(d, HIGH);
} else {
 digitalWrite(d, LOW);
}
if (digitos[dato] & (0x10)) {
digitalWrite(e, HIGH);
} else {
digitalWrite(e, LOW);
}
if (digitos[dato] & (0x20)) {
digitalWrite(f, HIGH);
} else {
digitalWrite(f, LOW);
}
if (digitos[dato] & (0x40)) {
digitalWrite(g, HIGH);
} else {
digitalWrite(g, LOW);
}
if (digitos[dato] & (0x80)) {
digitalWrite(dp, HIGH);
} else {
digitalWrite(dp, LOW);
}
switch (digito) {
case 1:
digitalWrite(d1, HIGH);
break;
case 2:
digitalWrite(d2, HIGH);
break;
case 3:
digitalWrite(d3, HIGH);
break;
case 4:
digitalWrite(d4, HIGH);
break;
}
}
 SENSOR DE ULTRASONIDO HC – SR04

El sensor HC-SR04 es un sensor de distancia de bajo costo, su uso es muy frecuente en la robótica,
utiliza transductores de ultrasonido para detectar objetos.

Su funcionamiento consiste en emitir un sonido ultrasónico por uno de sus transductores, y esperar
que el sonido rebote de algún objeto presente, el eco es captador por el segundo transductor. La
distancia es proporcional al tiempo que demora en llegar el eco.

Para empezar a utilizar el sensor HC-SR04 solo necesitas una placa Arduino, utilizaremos un Arduino
Uno R3, pero puedes utilizar cualquier placa de Arduino, el procedimiento es el mismo.

Empezamos insertando el sensor ultrasónico en un protoboard y con cables hacemos las siguientes
conexiones:

- Trigger del sensor al pin 2 del arduino

- Echo del sensor al pin 3 del arduino

También puedes conectar el módulo directamente al Arduino sin usar el protoboard.

Todas las conexiones se realizan con el Arduino Apagado (desconectado de la PC o de cualquier

fuente externa):

Primero configuramos los pines y la comunicación serial a 9600 baudios.

const int Trigger = 2; //Pin digital 2 para el Trigger del sensor

const int Echo = 3; //Pin digital 3 para el echo del sensor

void setup()
{
Serial.begin(9600); //iniciailizamos la comunicación
pinMode(Trigger, OUTPUT); //pin como salida
pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW); //Inicializamos el pin con 0
}

Ahora en el bucle void loop() empezamos enviando un pulso de 10us al Trigger del sensor

digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);

Seguidamente recibimos el pulso de respuesta del sensor por el pin Echo, para medir el pulso usamos
la función pulseIn(pin, value)

t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

La variable t, tiene el tiempo que dura en llegar el eco del ultrasonido, el siguiente paso es calcular la
distancia entre el sensor ultrasónico y el objeto

Partimos de la siguiente formula:

Donde Velocidad es la velocidad del sonido 340m/s, pero usaremos las unidades en cm/us pues
trabajaremos en centímetros y microsegundos, tiempo es el tiempo que demora en llegar el
ultrasonido al objeto y regresar al sensor, y la distancia recorrida es dos veces la distancia hacia el
objeto, reemplazando en la formula tenemos:

Finalmente enviamos serialmente el valor de la distancia y terminamos poniendo una pausa de

100ms, que es superior a los 60ms recomendado por los datos técnicos del sensor

A continuación se muestra el código completo del programa.

int TRIG = 3; // trigger en pin 10

int ECO = 2; // echo en pin 9
int LED = 13; // LED en pin 3
int DURACION;
int DISTANCIA;
void setup()
{
pinMode(TRIG, OUTPUT); // trigger como salida
pinMode(ECO, INPUT); // echo como entrada
pinMode(LED, OUTPUT); // LED como salida
Serial.begin(9600); // inicializacion de comunicacion serial a 9600 bps
}
void loop()
{
digitalWrite(TRIG, HIGH); // generacion del pulso a enviar
delay(1); // al pin conectado al trigger
digitalWrite(TRIG, LOW); // del sensor
DURACION = pulseIn(ECO, HIGH); // con funcion pulseIn se espera un pulso
// alto en Echo
DISTANCIA = DURACION / 58.2; // distancia medida en centimetros
Serial.println(DISTANCIA); // envio de valor de distancia por monitor serial
delay(200); // demora entre datos
if (DISTANCIA <= 5 && DISTANCIA >= 0){ // si distancia entre 0 y 5 cms.
digitalWrite(LED, HIGH); // enciende LED
delay(10);
}
digitalWrite(LED, LOW); // apaga LED
}