Hoy os enseño uno de mis primeros proyectos en el mundo maker: un marcador electrónico. Habiendo jugado a multitud de deportes en mi vida, siempre me fijaba en este dispositivo en todos los pabellones a los que iba.
En https://jjosemayorga.com/display-de-7-segmentos/ os conté los fundamentos del display de 7 segmentos, uno de los dispositivos electrónicos básicos más comúnmente utilizados.
Pues bien, en este proyecto que lo utilizaremos para su fin por excelencia: mostrar números. Pero este proyecto nos servirá además para comentar otros conceptos interesantes de electrónica/programación que podréis aplicar vuestros proyectos maker.
Objetivo del proyecto
Conocido el display de 7 segmentos y el circuito integrado 4511, vamos a diseñar y construir un marcador compuesto por dos displays que representarán un número de dos dígitos comprendidos entre el 0 y el 99. Un display muestra la cifra de decenas y el otro la de unidades.
Para darle una funcionalidad interesante, enviaremos el número a representar desde una aplicación desarrollada en Java, en la que haremos uso de la comunicación serie para transmitir la información necesaria desde el PC hasta el microcontrolador y viceversa.
En el montaje hardware incorporaremos además dos pulsadores que permiten incrementar o decrementar en una una unidad la cifra que tenemos en ese momento en el marcador.
En este caso, la placa de desarrollo empleada será Arduino UNO, el sanctasanctórum de los proyectos maker y que reinó durante muchos años en este mundillo.
Componentes del marcador electrónico
Para la construcción del marcador electrónico hemos empleado estos elementos:
- 1 x Arduino UNO rev 3
- 2 x display de 7 segmentos de cátodo común
- 2 x circuito integrado 4511
- 16 x resistencia 330 Ohm
- 27 x cables «jumper»
- 1 x protoboard
- 2 x pulsador 4 pines
Dispuestos según el siguiente esquema:
Aparte de los dos elementos principales, hay un par de conceptos que es necesario conocer para comprender el funcionamiento del proyecto.
Comunicación serie
La comunicación serie es el método básico con el que Arduino, u otra placa de desarrollo, se va a poder comunicar con el mundo exterior, y es que desde el mismo momento en que cargamos un programa en Arduino estamos haciendo uso de este tipo de comunicación sin saberlo.
Una de las primeras preguntas que le surge a todo maker novato una vez que ha completado todos los proyectos ejemplo del kit de iniciación es: «¿Y no podría ver la información de lo que tengo conectado a mi Arduino en el ordenador? O mejor aún…. ¿no podría enviarle información en tiempo real para hacer tal o cuál cosa cuando yo quiera?».
Porque programar el encendido de una tira de LEDs o hacer sonar una melodía en un zumbador es muy divertido y seguramente para un «curso cero» en un instituto eso ya nos proporcione horas y horas de diversión, pero el verdadero potencial de Arduino y similares nace en el momento en el que conseguimos que los dispositivos «hablen» entre sí.
No voy a entrar en detalles sobre comunicación en serie. Podéis encontrar artículos maravillosos a lo largo y ancho de la red como este, por ejemplo:
https://proyectoarduino.com/arduino-puerto-serie/
Tan sólo os resumo unos conceptos básicos para saber lo qué haremos en los códigos de este ejemplo.
- La comunicación serie emplea 2 hilos de comunicación: Tx (transmisión) y Rx (recepción).
- Utiliza un protocolo digital. Esto es, lo que circula por esos 2 hilos de comunicación es una secuencia de pulsos binarios, de modo que hay dos estados: uno alto, o 1, que se corresponde con el nivel de tensión alto (5 V en este caso) y otro bajo, o 0, que se corresponde con el nivel de tensión bajo (0 V).. La velocidad con la trabajan actualmente los procesadores permite enviar un grandísimo caudal de pulsos/bits por unidad tiempo, permitiendo enviar mensajes complejos desde el emisor al receptor y su interpretación en este último.
- La comunicación puede ser simplex, half duplex o full duplex, dependiendo de si permite comunicarse únicamente en una dirección, en las dos pero no al mismo tiempo o en las dos de manera simultánea, respectivamente. Full duplex es la forma de comunicación más versátil y comúnmente utilizada.
- En el caso concreto de Arduino UNO disponemos de 2 pines para realizar las comunicaciones serie. En el momento en que inicialicemos la funcionalidad de Tx/Rx ya no podremos utilizarlos para otra cosa.
- El conector USB ofrece también esta funcionalidad. De este modo, este conector hace las funciones de alimentar la placa de desarrollo y comunicarla con el PC. AL trabajar a los mismos niveles de tensión, podemos utilizar cables estándar (USB tipo A – USB tipo B, el clásico «cable de impresora»)..
Enumerados los conceptos clave, sólo nos queda saber cómo explotar esta funcionalidad.
Siempre recomiendo que cuando conectemos un dispositivo USB con el que queramos interactuar en nuestro PC, chequeemos en que puerto serie está. Hay software de configuración que lo reconoce automáticamente y otros que no.
Para ello, en Windows, debemos ir a Panel de control > Hardware y sonido > Administrador de dispositivos.
Bajo el apartado de Puertos (COM y LPT) aparecerán listados los dispositivos que tenemos conectados. En la imagen de ejemplo vemos que tenemos un Arduino UNO en el puerto COM9.
Al abrir el IDE de Arduino no ha reconocido la placa que acabo de conectar, por lo que, como había anticipado, tendré que introducirla.
Hecho esto, ya podemos acceder a una de las herramientas más interesantes del IDE: el Monitor Serie. En la captura anterior podéis ver en qué menú está. Y si le pulsamos se nos abrirá esta ventana de diálogo:
Es aquí donde van a aparecer todos los mensajes que nuestro Arduino lance por el puerto serie. Personalmente lo utilizo muy frecuentemente para depuración de código cuando estoy implantando funcionalidad compleja en mi Arduino.
El factor clave para que los mensajes se visualizan correctamente son los baudios, o lo que es lo mismo, el caudal de datos transmitidos. Antes os decía que la velocidad de los procesadores actuales permite transmitir muchos datos por unidad de tiempo. Podemos seleccionar a qué velocidad queremos hacer la transmisión de entre una gama de baudrate estándar: 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, ó115200 baud.
Pensaréis qué cuanto mayor sea este parámetro, mejor. Pero eso aumenta la probabilidad de fallo en la transmisión de datos, dando como resultado caracteres equivocados. Esto puede ser crítico por ejemplo en el caso de montar, por ejemplo, un servidor web, porque un carácter erróneo puede convertir una página HTML bien formateada en un caos ilegible.
De hecho, si directamente hacéis una selección incorrecta del baudrate, por ejemplo, querer leer a 9600 un dispositivo que emite a 115200, recibiréis un entramado de caracteres extraños.
Y bien, ya tenemos configurado todo, ¿cómo ponemos en marcha la funcionalidad y empezamos a intercambiar mensajes?
Si nos conformamos con comunicarnos a través del puerto USB, esto será realmente sencillo a través de los métodos de la clase Serial.
Básicamente emplearemos los siguientes comandos:
Serial.begin(9600) // Inicia el flujo de comunicación. 9600 es el baudrate. Podemos escoger otro de // entre los arriba listados.
Serial.println(variable) // Envía el valor de variable por al puerto serie (al PC, por ejemplo).
Serial.available() // Indica si hay hay algún mensaje disponible en el puerto serie (desde el PC).
Serial.readString() // Lee el mensaje disponible en el puerto serie.Como vemos, es muy sencillo utilizar la comunicación serie en Arduino. Conozcamos otro concepto nuevo antes de aplicar lo aprendido hasta ahora.
Resistencia pull-up
Si observamos la parte de los pulsadores en el esquema del montaje, veremos que la conexiones del pulsador son un poco peculiares. Sabemos que el pulsador tiene dos posiciones: abierto y cerrado. Entonces podríamos pensar que conocer su estado es tan fácil como conectar un terminal a tensión y el otro a un pin de Arduino configurado como entrada, de modo que si esa entrada detecta tensión es que hemos pulsado el pulsador.
Sin embargo, un pulsador abierto no garantiza que el voltaje en el terminal sin de retorno sea cero, ni un pulsador cerrado garantiza la tensión de entrada en el terminal de retorno.
Una forma de saber con exactitud si el pulsador está abierto o cerrado es conectar un terminal a tensión y otro a la tierra del montaje (la misma que para Arduino) e intercalar una resistencia en una de las conexiones.
En el ejemplo de una resistencia pull-up, esta resistencia está entre la fuente de tensión y el terminal «positivo» del pulsador y sacamos la señal de entrada a Arduino justamente del punto entre el terminal «positivo» del pulsador y la resistencia, tal como vemos en este esquema extraído de Wikipedia.
De este modo, cuando apretemos el pulsador y cerremos el circuito, nos estamos asegurando de que el valor recibido en el pin de entrada a Arduino es 0 (o LOW, tierra, GND, como queráis llamarlo).
Si nos decantásemos por usar una resistencia pull-down, intercalaríamos la resistencia entre el terminal «negativo» del pulsador y la tierra del montaje y sacaríamos la señal de entrada a Arduino de ese terminal, de forma que en este caso la indicación de pulsador cerrado vendría dada por una señal HIGH.
Código Arduino
Con los conceptos necesarios para entender el proyecto aclarados, es el momento de ponernos con el código que nos va a proporcionar las funcionalidades descritas y poner en marcha nuestro marcador electrónico. Empecemos por la parte de Arduino.
La información que va a circular entre Arduino y el PC por comunicación serie va a ser el número que tenemos representado en nuestro marcador.
Así, cuando desde el PC mandemos un número, Arduino lo leerá y lo representará en el marcador electrónico.
Recordemos también que hemos puesto dos pulsadores para incrementar o decrementar el número representado en una unidad, así que en este caso será Arduino el que envíe información (el nuevo número representado al PC). La comunicación es, por tanto, bidireccional.
Así pues, Arduino debe «estar atento» a cuál de las tres acciones se produce: recibir número por puerto serie, incrementar número pulsado o decrementar número pulsado. Estas serán las tres condiciones que aparecerá entonces en el bucle de ejecución loop.
Escribiremos varios métodos para definir qué se hace en cada caso.
Y el código completo es este:
const int pinAd=2;
const int pinBd=3;
const int pinCd=4;
const int pinDd=5;
const int pinAu=7;
const int pinBu=8;
const int pinCu=9;
const int pinDu=10;
String inByte = "00";
int numero=0;
const int restar=A0;
const int sumar=A1;
String numerostr="00";
void setup()
{
pinMode(pinAd,OUTPUT);
pinMode(pinBd,OUTPUT);
pinMode(pinCd,OUTPUT);
pinMode(pinDd,OUTPUT);
pinMode(pinAu,OUTPUT);
pinMode(pinBu,OUTPUT);
pinMode(pinCu,OUTPUT);
pinMode(pinDu,OUTPUT);
pinMode(restar,INPUT);
pinMode(sumar,INPUT);
Serial.begin(9600); //Open the serial port
}
void loop()
{
if((digitalRead(sumar)==LOW)&&(numero<99))
{
numero=numero+1;
numerostr=String(numero);
enciende(numerostr);
Serial.println(numero);
delay(200);//para detener el loop y que no sume más de 1 al presionar el botón
}
if((digitalRead(restar)==LOW)&&(numero>0))
{
numero=numero-1;
numerostr=String(numero);
enciende(numerostr);
Serial.println(numero);
delay(200);
}
if(Serial.available() > 0)
{
inByte = Serial.readString();; //read the incoming byte
numero=inByte.toInt();
Serial.println(numero);
numerostr=String(numero);
enciende(numerostr);
}
}
void enciende(String numberstr)
{
char decenas = numberstr.charAt(0);
char unidades = numberstr.charAt(1);
if(numberstr.length()<2)
{
unidades=decenas;
decenas='0';
}
if(decenas == '0')
{
encenderd0();
}
else if(decenas == '1')
{
encenderd1();
}
else if(decenas == '2')
{
encenderd2();
}
else if(decenas == '3')
{
encenderd3();
}
else if(decenas == '4')
{
encenderd4();
}
else if(decenas == '5')
{
encenderd5();
}
else if(decenas == '6')
{
encenderd6();
}
else if(decenas == '7')
{
encenderd7();
}
else if(decenas == '8')
{
encenderd8();
}
else if(decenas == '9')
{
encenderd9();
}
if(unidades == '0')
{
encenderu0();
}
else if(unidades == '1')
{
encenderu1();
}
else if(unidades == '2')
{
encenderu2();
}
else if(unidades == '3')
{
encenderu3();
}
else if(unidades == '4')
{
encenderu4();
}
else if(unidades == '5')
{
encenderu5();
}
else if(unidades == '6')
{
encenderu6();
}
else if(unidades == '7')
{
encenderu7();
}
else if(unidades == '8')
{
encenderu8();
}
else if(unidades == '9')
{
encenderu9();
}
}
void encenderu0()
{
digitalWrite(pinAu, LOW);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, LOW);
}
void encenderu1()
{
digitalWrite(pinAu, HIGH);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, LOW);
}
void encenderu2()
{
digitalWrite(pinAu, LOW);
digitalWrite(pinBu, HIGH);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, LOW);
}
void encenderu3()
{
digitalWrite(pinAu, HIGH);
digitalWrite(pinBu, HIGH);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, LOW);
}
void encenderu4()
{
digitalWrite(pinAu, LOW);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, HIGH);
digitalWrite(pinDu, LOW);
}
void encenderu5()
{
digitalWrite(pinAu, HIGH);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, HIGH);
digitalWrite(pinDu, LOW);
}
void encenderu6()
{
digitalWrite(pinAu, LOW);
digitalWrite(pinBu, HIGH);
digitalWrite(pinCu, HIGH);
digitalWrite(pinDu, LOW);
}
void encenderu7()
{
digitalWrite(pinAu, HIGH);
digitalWrite(pinBu, HIGH);
digitalWrite(pinCu, HIGH);
digitalWrite(pinDu, LOW);
}
void encenderu8()
{
digitalWrite(pinAu, LOW);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, HIGH);
}
void encenderu9()
{
digitalWrite(pinAu, HIGH);
digitalWrite(pinBu, LOW);
digitalWrite(pinCu, LOW);
digitalWrite(pinDu, HIGH);
}
void encenderd0()
{
digitalWrite(pinAd, LOW);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, LOW);
}
void encenderd1()
{
digitalWrite(pinAd, HIGH);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, LOW);
}
void encenderd2()
{
digitalWrite(pinAd, LOW);
digitalWrite(pinBd, HIGH);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, LOW);
}
void encenderd3()
{
digitalWrite(pinAd, HIGH);
digitalWrite(pinBd, HIGH);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, LOW);
}
void encenderd4()
{
digitalWrite(pinAd, LOW);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, HIGH);
digitalWrite(pinDd, LOW);
}
void encenderd5()
{
digitalWrite(pinAd, HIGH);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, HIGH);
digitalWrite(pinDd, LOW);
}
void encenderd6()
{
digitalWrite(pinAd, LOW);
digitalWrite(pinBd, HIGH);
digitalWrite(pinCd, HIGH);
digitalWrite(pinDd, LOW);
}
void encenderd7()
{
digitalWrite(pinAd, HIGH);
digitalWrite(pinBd, HIGH);
digitalWrite(pinCd, HIGH);
digitalWrite(pinDd, LOW);
}
void encenderd8()
{
digitalWrite(pinAd, LOW);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, HIGH);
}
void encenderd9()
{
digitalWrite(pinAd, HIGH);
digitalWrite(pinBd, LOW);
digitalWrite(pinCd, LOW);
digitalWrite(pinDd, HIGH);
}
Código Java
¿Y qué vamos a tener en la parte del PC para controlar nuestro marcados electrónico? Pues en este caso he diseñado una sencilla aplicación de escritorio en lenguaje Java. Esta aplicación está hecha en código Java puro, sin hacer uso de ningún framework ni ninguna funcionalidad del IDE para generar interfaces gráficas. Lo podéis compilar tal cual aparece aquí (evidentemente, teniendo instalado el jdk en nuestro PC, y os funcionará.
El único «añadido» son las librerías para usar la comunicación serie. Sus nombres son RXTXcomm.jar, rxtxSerial.dll y rxtxParallel.dll. Podéis encontrarlas en algunos repositorios de Internet.
Para que funcionen tan sólo debemos hacer lo siguiente:
Copiar RXTXcomm.jar en el directorio <JAVA_HOME>\jre\lib\ext.
Copiar rxtxSerial.dll en el directorio <JAVA_HOME>\jre\bin y en el directorio windows/system32.
Copiar rxtxParallel.dll en el directorio <JAVA_HOME>\jre\bin y en el directorio windows/system32
siendo <JAVA_HOME> la ruta donde habéis instalado JDK (Java Development Kit).
Y ahora sí, el código. Es un poco caótico porque he mezclado la parte gráfica con las funcionalidades en un intento de hacer todo en un único archivo que podrías componer directamente en el bloc de notas, por ejemplo. Si sois puretas de la programación, os sangrarán los ojos.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Enumeration;
public class display7s implements SerialPortEventListener
{
JFrame marco=new JFrame("Display de 7 segmentos");
JLabel numeroactual=new JLabel("<html><font size=5>Número actual:</font></size>");
JTextField numact=new JTextField("0", 20);
JPanel digitos=new JPanel();
JLabel decima=new JLabel(new ImageIcon("seg0.gif"));
JLabel uniima=new JLabel(new ImageIcon("seg0.gif"));
int unidades=0;
int decenas=0;
int numerorecibido=0;
JLabel enviarnumero=new JLabel("<html><font size=5>Enviar número:</font></size>");
JTextField envnum=new JTextField(20);
JButton enviar=new JButton("<html><font size=5>ENVIAR</font></size>");
int numeroenviado=0;
/** The output stream to the port */
private OutputStream output = null;
private BufferedReader input;
SerialPort serialPort;
private final String PORT_NAME = "COM13";
/** Milliseconds to block while waiting for port open */
private static final int TIME_OUT = 2000;
/** Default bits per second for COM port. */
private static final int DATA_RATE = 9600;
display7s()
{
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setIconImage(Toolkit.getDefaultToolkit().createImage("7-segment-led.png"));
marco.setResizable(false);
GridBagLayout gridbag=new GridBagLayout();
GridBagConstraints gbc=new GridBagConstraints();
marco.setLayout(gridbag);
gbc.insets=new Insets(5,20,5,20);
gbc.gridx=0;
gbc.gridy=0;
gbc.gridwidth=2;
gbc.gridheight=1;
marco.add(numeroactual,gbc);
gbc.gridx=0;
gbc.gridy=1;
gbc.gridwidth=2;
gbc.gridheight=1;
numact.setEditable(false);
numact.setBackground(Color.white);
marco.add(numact,gbc);
digitos.setLayout(new GridLayout(1,2));
digitos.add(decima);
digitos.add(uniima);
gbc.gridx=0;
gbc.gridy=2;
gbc.gridwidth=2;
gbc.gridheight=1;
marco.add(digitos,gbc);
gbc.gridx=0;
gbc.gridy=3;
gbc.gridwidth=2;
gbc.gridheight=1;
gbc.anchor=GridBagConstraints.CENTER;
marco.add(enviarnumero,gbc);
gbc.gridx=0;
gbc.gridy=4;
gbc.gridwidth=2;
gbc.gridheight=1;
marco.add(envnum,gbc);
gbc.gridx=0;
gbc.gridy=5;
gbc.gridwidth=2;
gbc.gridheight=1;
enviar.setName("enviar");
enviar.setToolTipText("Enviar número");
enviar.addMouseListener(new Seleccion());
marco.add(enviar,gbc);
initialize();
marco.pack();
marco.setLocationRelativeTo(null);
marco.setVisible(true);
}
public void initialize()
{
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
// iterate through, looking for the port
while (portEnum.hasMoreElements())
{
CommPortIdentifier currPortId = (CommPortIdentifier)
portEnum.nextElement();
if (PORT_NAME.equals(currPortId.getName()))
{
portId = currPortId;
break;
}
}
if (portId == null)
{
System.out.println("Could not find COM port.");
return;
}
try
{
// open serial port, and use class name for the appName.
serialPort = (SerialPort) portId.open(this.getClass().getName(),
TIME_OUT);
// set port parameters
serialPort.setSerialPortParams(DATA_RATE,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
// open the streams
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
// add event listeners
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
}
catch (Exception e)
{
System.err.println(e.toString());
}
}
public synchronized void close()
{
if (serialPort != null)
{
serialPort.removeEventListener();
serialPort.close();
}
}
/**
* Handle an event on the serial port. Read the data and print it.
*/
public synchronized void serialEvent(SerialPortEvent oEvent)
{
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE)
{
try
{
String inputLine=input.readLine();
//System.out.println(inputLine);
numact.setText(inputLine);
numerorecibido=Integer.parseInt(inputLine);
decenas=(int)Math.floor(numerorecibido/10);
unidades=numerorecibido-(decenas*10);
numgraf(decenas,unidades);
//lect=Integer.parseInt(inputLine);
//slider.setValue(lect);
} catch (Exception e) {
System.err.println(e.toString());
}
}
}
private void sendData(String data)
{
try
{
output.write(data.getBytes());
} catch (IOException e) {
showError("Error sending data");
//System.exit(ERROR);
}
}
private void showError(String errorMessage){
JOptionPane.showMessageDialog(marco,
errorMessage,
"Error",
JOptionPane.ERROR_MESSAGE);
}
class Seleccion extends MouseAdapter
{
public void mousePressed(MouseEvent e)
{
Component aux=e.getComponent();
}
public void mouseReleased(MouseEvent e)
{
Component aux=e.getComponent();
{
if(aux.getName().equals("enviar"))
{
try
{
numeroenviado=Integer.parseInt(envnum.getText());
if(numeroenviado>99||numeroenviado<0)
{
JOptionPane.showMessageDialog(new JFrame(), "El número enviado debe estar comprendido entre 0 y 99", "Error en datos de entrada", JOptionPane.ERROR_MESSAGE);
}
else
{
sendData(envnum.getText());
}
}
catch(NumberFormatException f)
{
JOptionPane.showMessageDialog(new JFrame(), "Debe introducir un número entero", "Error en datos de entrada", JOptionPane.ERROR_MESSAGE);
}
}
}
}
}
void numgraf(int dtir, int utir)
{
switch(dtir)
{
case 0:
decima.setIcon(new ImageIcon("seg0.gif"));
break;
case 1:
decima.setIcon(new ImageIcon("seg1.gif"));
break;
case 2:
decima.setIcon(new ImageIcon("seg2.gif"));
break;
case 3:
decima.setIcon(new ImageIcon("seg3.gif"));
break;
case 4:
decima.setIcon(new ImageIcon("seg4.gif"));
break;
case 5:
decima.setIcon(new ImageIcon("seg5.gif"));
break;
case 6:
decima.setIcon(new ImageIcon("seg6.gif"));
break;
case 7:
decima.setIcon(new ImageIcon("seg7.gif"));
break;
case 8:
decima.setIcon(new ImageIcon("seg8.gif"));
break;
case 9:
decima.setIcon(new ImageIcon("seg9.gif"));
break;
}
switch(utir)
{
case 0:
uniima.setIcon(new ImageIcon("seg0.gif"));
break;
case 1:
uniima.setIcon(new ImageIcon("seg1.gif"));
break;
case 2:
uniima.setIcon(new ImageIcon("seg2.gif"));
break;
case 3:
uniima.setIcon(new ImageIcon("seg3.gif"));
break;
case 4:
uniima.setIcon(new ImageIcon("seg4.gif"));
break;
case 5:
uniima.setIcon(new ImageIcon("seg5.gif"));
break;
case 6:
uniima.setIcon(new ImageIcon("seg6.gif"));
break;
case 7:
uniima.setIcon(new ImageIcon("seg7.gif"));
break;
case 8:
uniima.setIcon(new ImageIcon("seg8.gif"));
break;
case 9:
uniima.setIcon(new ImageIcon("seg9.gif"));
break;
}
}
public static void main(String[] args)
{
display7s app=new display7s();
}
}Prueba de funcionamiento del marcador electrónico
Llega el momento de ver nuestro marcador electrónico en acción…
Se podía hacer para controlar 4 displais dobles de 7 segmentos, que vayan de 00 a 99 y que se puedan avanzar o retrasar mediante un mando con pulsadores de modo inalámbrico?
Sí, por supuesto.
Necesitarías 4 displays y sus correspondientes circuitos integrados y enviar la señales de encendido y apagado de manera temporizada.
Para utilizar un mando inalámbrico tendrías que instalar un dispositivo como un módulo bluetooth, Wi-Fi etc. que permita establecer comunicación inalámbrica. Tengo algún artículo al respecto, como este: https://jjosemayorga.com/aplicacion-android-con-funcionalidad-bluetooth/. Tendrías que unir todas las funcionalidades que necesites en el mismo código.