PRACTICA

DISPLAY
ARDUINO
 INTRODUCCIÓN

A continuación, diseñamos dos circuitos en tinkercad, el primer

ejercicio consiste en conectar un display a un arduino y crear una
función que haga lo siguiente:

 Realizar una cuenta de 2 en 2.

 El conteo debe empezar en 0 hasta el 8 y al finalizar empezar
del 1 hasta el 9.
 Los pasos anteriores se repetirán constantemente, hasta detener
la simulación.

El segundo ejercicio consiste en conectar 3 displays, dos de ellos

representarán las entradas que ingrese el usuario (ya sea 1 o 0) y nos
encargamos de configurar el arduino para que en el tercer display se
muestre la salida (resultado), simulando las funciones de una
compuerta AND y una compuerta OR.

1
 Tercer Práctica
Comenzamos creando el circuito de conteo

Buscamos los componentes que vamos a utilizar:

 Arduino uno R3.

 7 Resistencias.
 Visualizador de siete segmentos.

El visualizador de siete segmentos (también llamado display) es una forma de

representar caracteres en equipos electrónicos. Está compuesto de siete
segmentos que se pueden encender o apagar individualmente. Cada segmento
tiene la forma de una pequeña línea y está representada por una letra, existen
varios tipos de displays, para esta práctica utilizaremos uno de 7 segmentos de
cátodo común.

2
Para comenzar vamos a conectar cada terminal a una resistencia y después al
arduino, a las resistencias les pusimos un valor de 220Ω, como se mencionó
anteriormente cada segmento está representado por una letra, por lo tanto,
tenemos que prestar atención en cual pin vamos a conectarlos.

Nosotros hicimos las conexiones de la siguiente manera:

 Terminal A a pin 12.

 Terminal B a pin 13.
 Terminal C a pin 7.
 Terminal D a pin 8.
 Terminal E a pin 9.
 Terminal F a pin 11.
 Terminal G a pin 10.
 Las terminales Común a pin GND (tierra).

La terminal DP no la conectamos porque consideramos que no era necesario

incluir el punto.

Después trabajamos en el código de programación de arduino, para ello nos

vamos a la parte superior donde dice “código”, nos aparecerá una ventana donde
tenemos que desplegar el menú que dice “bloques” y cambiarlo a “texto”.

3
 1

Presentamos y explicamos el código:

// C++ code
//Primero declaramos variables al que están conectados los pines de nuestro display e
iniciar variables que utilizaremos más adelante
int Pint_A = 12;
int Pint_B = 13;
int Pint_C = 7;
int Pint_D = 8;
int Pint_E = 9;
int Pint_F = 11;
int Pint_G = 10;
int n = 0;

//En esta parte declaramos si lo que conectamos es un componente de entrada o salida,

como todos son terminales del display, se declaran como salida (output).
void setup()
{
pinMode(Pint_A, OUTPUT);
pinMode(Pint_B, OUTPUT);
pinMode(Pint_C, OUTPUT);
pinMode(Pint_D, OUTPUT);
pinMode(Pint_E, OUTPUT);
pinMode(Pint_F, OUTPUT);
pinMode(Pint_G, OUTPUT);
}

4
void loop()
{
funcion();
}

void off() //Esta es una función que apaga todos los segmentos del display
{
digitalWrite(Pint_A,LOW);
digitalWrite(Pint_B,LOW);
digitalWrite(Pint_C,LOW);
digitalWrite(Pint_D,LOW);
digitalWrite(Pint_E,LOW);
digitalWrite(Pint_F,LOW);
digitalWrite(Pint_G,LOW);
}

//Como mencionamos anteriormente se busca que inicie con 0 el conteo, pero después
debe empezar con 1, por lo tanto se hacen dos condiciones dentro de la función.
void funcion()
{
if(n == 0) //Condición cuando inicie en 0
{ //Encendemos los segmentos que representen el número
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
digitalWrite(Pint_D,HIGH);
digitalWrite(Pint_E,HIGH);
digitalWrite(Pint_F,HIGH);
delay(1000);
off();
for(int c=5;c>0;c++) //Ciclo con el que realizará el conteo de 2 en 2 y condiciones para
que se enciendan los segmentos que representen cada número.
{

5
n = n + 2;
if (n == 2)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_G,HIGH);
digitalWrite(Pint_E,HIGH);
digitalWrite(Pint_D,HIGH);
delay(1000);
off();
}
if (n == 4)
{
digitalWrite(Pint_F,HIGH);
digitalWrite(Pint_G,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
delay(1000);
off();
}
if (n == 6)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_F,HIGH);
digitalWrite(Pint_G,HIGH);
digitalWrite(Pint_E,HIGH);
digitalWrite(Pint_C,HIGH);
digitalWrite(Pint_D,HIGH);
delay(1000);
off();
}

6
 if (n == 8)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
digitalWrite(Pint_D,HIGH);
digitalWrite(Pint_E,HIGH);
digitalWrite(Pint_F,HIGH);
digitalWrite(Pint_G,HIGH);
delay(1000);
off();
}
}
}
n = 1; //Al finalizar el ciclo “for” iniciamos nuestra variable de conteo a 1 para que entre a
la siguiente condición
if (n == 1) //Condición cuando inicie en 0
{ //Encendemos los segmentos que representen el número
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
delay(1000);
off();
for(int c=5;c>0;c++) //Ciclo con el que realizará el conteo de 2 en 2 y condiciones para
que se enciendan los segmentos que representen cada número.
{
n = n + 2;
if (n == 3)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_G,HIGH);
digitalWrite(Pint_C,HIGH);

7
 digitalWrite(Pint_D,HIGH);
delay(1000);
off();
}
if (n == 5)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_F,HIGH);
digitalWrite(Pint_G,HIGH);
digitalWrite(Pint_C,HIGH);
digitalWrite(Pint_D,HIGH);
delay(1000);
off();
}
if (n == 7)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
delay(1000);
off();
}
if (n == 9)
{
digitalWrite(Pint_A,HIGH);
digitalWrite(Pint_B,HIGH);
digitalWrite(Pint_C,HIGH);
digitalWrite(Pint_D,HIGH);
digitalWrite(Pint_F,HIGH);
digitalWrite(Pint_G,HIGH);
delay(1000);

8
 off();
}
}
} n = 0; //Al finalizar el ciclo “for” iniciamos nuestra variable de conteo a 0 para que entre
a la siguiente condición
}
En cada condición después de encender los segmentos se les deja un tiempo y
después se utiliza la función de apagar puesto que, si no se hace eso, el display
no puede hacer ningún otro cambio.

9
Ahora continuamos con el siguiente ejercicio en el cual representaremos las
funciones de las compuertas lógicas AND y OR. Iniciamos creando un nuevo
circuito Buscamos los componentes que vamos a utilizar:

 Arduino uno R3.

 Placa de pruebas pequeña
 9 Resistencias.
 3 Displays (Visualizador de siete segmentos).
 3 Interruptores deslizantes.

Igual que con el ejercicio anterior vamos a utilizar los display 7 segmentos cátodo
común, comenzaremos con las conexiones, primeramente, posicionamos el
arduino y la placa de pruebas, como en este ejercicio solo queremos mostrar los
números 1 o 0 en los displays no usamos todos los segmentos del display y por lo
tanto se decidió que los segmentos B y C que muestran el número 1 se
conectarían juntos al igual que los segmentos A, F, E y D para no hacer más
grande el circuito.

Hicimos las conexiones de la siguiente manera:

 Pin 13 a terminal F del display1 (recordando que está en serie con A, E Y

D).
 Pin 12 a terminal B del display1 (recordando que está en serie con C).
 Pin 11 a terminal F del display2
 Pin 10 a terminal F del display3
 Pin 9 a terminal B del display2
 Pin 8 a terminal B del display3
 Las terminales Común a pin GND (tierra).

Las terminales G y DP no las conectamos porque no eran necesarias.

 Común de los interruptores a 5v

 Terminal 2 de interruptor1 al pin 7
 Terminal 2 de interruptor2 al pin 8

10
  Terminal 2 de interruptor3 al pin 9

También se debe conectar una resistencia de terminal2 a tierra de cada

interruptor.

Colocamos 3 interruptores puesto que los primeros dos se encargarán de

transmitir la entrada que elija el usuario a los display, mientras que el tercer
interruptor permitirá que el usuario elija si quiere que el circuito haga la función de
compuerta AND o de OR, la cual se especificará en el código.

Después trabajamos en el código de programación de arduino, para ello nos

vamos a la parte superior donde dice “código”; a continuación, mostramos y
explicamos el código:

// C++ code
// Comenzamos declarando las variables

int PinA0 = 13; //Display1 segmentos para 0

int PinA1 = 12; //Display1 segmentos para 1
int PinB0 = 11; //Display2 0
int PinB1 = 9; //Display2 1
int PinR0 = 10; //Display3 0

11
int PinR1 = 8; //Display3 1
int PinEnt1 = 7; //Interruptor 1

int PinEnt2 = 6; //Interruptor2

int PinP = 5; //Interruptor3
int ent1 = 0;
int ent2 = 0;
int entP = 0;

//En esta parte declaramos si lo que conectamos es un componente de entrada o salida.

void setup()
{
pinMode(PinA0, OUTPUT);
pinMode(PinA1, OUTPUT);
pinMode(PinB0, OUTPUT);
pinMode(PinB1, OUTPUT);
pinMode(PinR0, OUTPUT);
pinMode(PinR1, OUTPUT);
pinMode(PinEnt1, INPUT);
pinMode(PinEnt2, INPUT);
pinMode(PinP, INPUT);
}

void loop()
{
Funcion();
Puertalogic();
}

//Función para apagar los segmentos del display 1

void offA()
{
digitalWrite(PinA0,LOW);
digitalWrite(PinA1,LOW);
}

12
//Función para apagar los segmentos del display 2
void offB()

{
digitalWrite(PinB0,LOW);
digitalWrite(PinB1,LOW);
}

//Función para apagar los segmentos del display 3

void offR()
{
digitalWrite(PinR0,LOW);
digitalWrite(PinR1,LOW);
}

//Función principal, solo muestra en el display 1 y 2 lo que el usuario escoge

void Funcion()
{
ent1 = digitalRead(PinEnt1); //Lee el estado del 1 interruptor
ent2 = digitalRead(PinEnt2); //Lee el estado del 2 interruptor

if(ent1 == true) { //si el interruptor 1 esta encendido

offA();
digitalWrite(PinA1, HIGH);
}else{ //si el interruptor 1 está apagado
offA();
digitalWrite(PinA0, HIGH);
digitalWrite(PinA1,HIGH);
}

if(ent2 == true) { //si el interruptor 2 esta encendido

offB();
digitalWrite(PinB1, HIGH);
}else{ //si el interruptor 2 está apagado
offB();
digitalWrite(PinB0, HIGH);
digitalWrite(PinB1,HIGH);

13
 }
}

void Puertalogic() //Funcion para la salida del 3 display, si el tercer interruptor esta=
Encendido: AND, Apagado: OR

{
entP = digitalRead(PinP); //Lee el estado del 3 interruptor
ent1 = digitalRead(PinEnt1); //Lee el estado del 1 interruptor
ent2 = digitalRead(PinEnt2); //Lee el estado del 2 interruptor

if (entP == true)
{
if(ent1 == true && ent2 == true) //Condición para un comportamiento como AND
{
offR();
digitalWrite(PinR1,HIGH);
}else{
offR();
digitalWrite(PinR0, HIGH);
digitalWrite(PinR1,HIGH);
}
}else{
if(ent1 == true || ent2 == true) //Condición para comportamiento como compuerta OR
{
offR();
digitalWrite(PinR1,HIGH);
}else{
offR();
digitalWrite(PinR0, HIGH);
digitalWrite(PinR1,HIGH);
}
}
}

14
En cada condición antes de encender los segmentos, utilizamos la función de
apagar ya que, si no, no puede hacer ningún cambio.

15