Descripción:
Marcador de 2 dígitos de 7 segmentos con 4 leds rojos cada uno de ellos. Cada dígito está controlado por un shift register (74HC595N). Un pulsador central de dos poiciones permite la marcación manual del operario. Dos sensores de ultrasonidos (HC-SR04) a ambos lados detectan el paso de corredores. Un módulo de Bluetooth (HC-05) permite la manipulación desde una aplicación realizada en Mit App Inventor para Android.
Materiales empleados
Fabricación de los segmentos de los dígitos.
Mi primer paso fue buscar displays grandes de 7 segmentos en internet para tomar referencias. Encontré este tipo de módulos que se venden a bajo coste.
Basándome en el diseño, decidí realizar unos módulos parecidos a los del ejemplo, que se encajaran sobre una plantilla fija con la forma del dígito. Además, me pareció una buena idea proteger los leds con una superficie de material traslúcido. Estos protectores se encajan con unas pestañas sobre los módulos que contienen los leds, que a su vez irán atornillados con dos tornillos sobre el soporte.
Electrónica en los segmentos.
Este punto es importante a la hora de desarrollar el proyecto, se trata de calcular las resistencias para los leds de los 7 segmentos. De esta decisión dependerá el consumo y por tanto durabilidad de la fuente de alimentación (pilas, baterías, powerbank, etc). En mi caso y tras los cálculos me decanté por usar una fuente de móviles de 5V externa, que me aseguraba una buena durabilidad y simplificaba los problemas de alimentación pues administra 5V que es ideal para el funcionamiento de mi arduino y de todos los componentes.
Llegados a este punto me decidí por usar 4 leds rojos por segmento. De esta manera se distribuirán en 2 leds en serie compartiendo una resistencia cuyos cálculos me daban como resultado que debía ser de 68 Ohmios.
Las resistencias de valor comercial más cercanas de las que disponía eran de 56 Ohmios que son las que usé en el proyecto.
A grandes rasgos y sin entrar en mucho detalle los cálculos los realicé de la siguiente manera y usando esta aplicación online para este propósito.
Teoría de control de displays de 7 segmentos.
Para el control de los archiconocidos displays de 7 segmentos conviene repasar algunos conceptos fundamentales.
Los segmentos son nombrados por letras A, B, C, D, F, E, G que podemos considerar como leds.
Con arduino podríamos encender cada uno de los 7 leds usando un pin de salida para cada uno, pero como usaré dos dígitos, esto necesitaría 14 pines de salida, lo que no me permitiría conectar los demás sensores.
Para eso están los shift registers como el 74HC959N. Que usando 3 pines digitales del arduino son capaces de hacer lucir 8 leds. Además, permite conectar otros 74HC959N en cadena, multiplicando esta peculiaridad.
Puesto que para el proyecto necesitamos encender 14 segmentos, debemos emplear dos chips 74HC959N enlazados y las conexiones serían de la siguiente forma.
Los leds rojos representados en la imagen corresponden a los segmentos de cada número. La resistencia de protección de 180 ohms que aparece en la imagen será sustituida por la que se habló en el apartado anterior de 56 ohms.
Obsérvese que la alimentación es de 5V y que el pin de salida SQH está conectado al pin de entrada el segundo chip.
En nuestro caso, los pines de conexión con el primer chip serán los siguientes:
- El pin 14 del primer 74HC959N (data) se conectará al pin 2 del arduino Nano.
- El pin 12 del primer 74HC959N (Latch Clock ) se conectará al pin 3 del arduino Nano.
- El pin 11 del primer 74HC959N (Shift Clock ) se conectará al pin 4 del arduino Nano.
Por otra parte, las conexiones al chip número 2 serán estas:
- El pin 14 del segundo 74HC959N (data) se conectará al pin 9 (SQH) del primer 74HC959N.
- El pin 12 del primer 74HC959N (Latch Clock ) se conectará al pin 3 del arduino Nano.
- El pin 11 del primer 74HC959N (Shift Clock ) se conectará al pin 4 del arduino Nano.
Como se muestra en el esquema.
Para facilitar las conexiones y debido a las gran cantidad de cables que salen de los segmentos, he diseñados las siguientes PCBs dedicadas para albergar los chips 74HC959N por separado del cuerpo central y que tienen su hueco para encajar con tornillos. Se usarán las mismas PCBs en los dos chips, teniendo en cuenta que han de unirse a través de un puente de cables entre ellos en disposición adecuada (ver imagen más abajo).
Se pueden descargar y fresar en una CNC sobre placas de cobre.
Código para control de los 74HC595
Declaración de los pines de salida de arduino para manejar los chips.
const int dataPin = 2; // Pin conectado al Pin 14 del 74HC595 (Data)
const int latchPin = 3; // Pin conectado al Pin 12 del 74HC595 (Latch)
const int clockPin = 4; // Pin conectado al Pin 11 del 74HC595 (Clock)Tabla de asignación de segmentos encendidos de acuerdo al número a mostrar.
Dependiendo de la forma de soldar de cada uno, deberemos cambiar las asignaciones en binario de las siguientes líneas.
Aquí se muestra los segmentos a encender por el 74HC595 dispuestos en binario y teniendo en cuenta el orden de segmentos según su letra.
En mi caso ha quedado así:
// 7 segementos dígitos
const byte dos[11] = { //Para el chip numero 2
0b01111011, // número 0
0b00100010, // número 1
0b01011110, // número 2
0b01101110, // número 3
0b00100111, // número 4
0b01101101, // número 5
0b01111101, // número 6
0b00101010, // número 7
0b01111111, // número 8
0b01101111, // número 9
0b00000000, // Apagado total
};
const byte uno[11] = {
0b01110111, // numero 0
0b00000110, // numero 1
0b00111101, // numero 2
0b00011111, // numero 3
0b01001110, // numero 4
0b01011011, // numero 5
0b01111011, // numero 6
0b00010110, // numero 7
0b01111111, // numero 8
0b01011111, // numero 9
0b00000000, // apagado total
}Nótese que como soldé los segmentos sin ningún criterio, tuve que ir probando dígito y número a número hasta encontrar la posición correcta de cada uno de los números de cada dígito. Por este motivo se aprecia cierto caos en la asignación de 1 y 0 en el código, pues 1 corresponde a segmento encendido y 0 corresponde a segmento apagado (el inicio de la línea 0b, corresponde a la declaración de que la cifra que sigue está en binario).
Al final del código se implementará el siguiente void(), que básicamente lo que hace es poner en bajo nivel el pin LATCH (pin3) para manifestar al 74HC595 que va a recibir nuevos datos. Posterior mente se envían estos mediente el comando
shiftOut(dataPin, clockPin, LSBFIRST, dos[d]);
En donde ‘dos’ es el nombre del segundo 74HC595 que controla los segmentos que deben encenderse del dígito correspondiente a las decenas, y ‘d’ que es el valor de las decenas.
luego hacemos lo mismo con
shiftOut(dataPin, clockPin, LSBFIRST, uno[u]);
Donde ‘uno’ corresponde al nombre de los segmentos de los que se hace cargo el primer chip 74HC959 y ‘u’ al valor de las unidades a mostrar.
void muestra (int d, int u) {
delay (10);
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, dos[d]);
shiftOut(dataPin, clockPin, LSBFIRST, uno[u]);
digitalWrite(latchPin, HIGH);
}Por último, para mostrar el número deseado, se llama a la función ‘muestra’ mediante el la llamada:
muestra(decena, unidad);
Sensores de ultrasonidos HC-SR04
Superconocidos son estos sensores de ultrasonidos que disponen de un emisor y un receptor de sonido en la misma placa. Fáciles de usar y más aún empleando librerías como la <NewPing.h> que simplifica todo el proceso.
#include <NewPing.h>
Estos sensores se colocarán en los extremos del contador con el objetivo de detectar el paso de algún obstáculo que pase cerca, contando así un número más en el dígito correspondiente. Se puede dejar el artefacto colocado en una mesa dentro de un circuito de carreras que permita el paso cerca de estos detectores para conocer la cantidad de corredores por cada lado.
El gran inconveniente de este tipo de sensores es que depende mucho de las condiciones del entorno, es decir, no se comporta igual en interiores que en exteriores y muestra distintos comportamiento dependiendo de la capacidad de rebote de los sonidos de estos. Pero teniendo en cuenta que no se usarán para medir distancias sino para controlar el paso de objetos, puede desempeñar bien su trabajo.
Otro gran inconveniente del empleo de estos sensores es que por algún motivo que desconozco, dejan de funcionar o lo hacen de manera errática cuando está en funcionamiento el Bluetooth.
No se si es debido a la librería empleada o a las interferencias sonoras que puedan tener, el caso es que subsané este problema de la manera más simple que se me ocurrió.
La idea fue poner un interruptor (palanca) para distinguir entre manual y automático, así, cuando la palanca está en manual, activa el BT y desactiva los sensores HC-SR04 y viceversa, cuando está en automático, se deja de alimentar el BT y se activan los sensores ultrasónicos.
Esta palanca la conectaremos al pin analógico A2, que se comportará como digital entrada digital pues así será declarado posteriormente en el sketch y GND.
Esta interruptor no llevará resistencias adicionales por lo que emplearé la ventaja de usar la que para este motivo incorpora arduino. Tendremos que declararlo así en el setup del sketch.
pinMode (interruptor, INPUT_PULLUP);
Pulsador de dos posiciones
Al igual que con el interruptor de palanca, con este pulsador usaremos los pines analógicos A0 y A1 pero declarándolos como entradas digitales y de la misma manera que comentamos en el apartado anterior, aprovechando la resistencia pull-up de arduino.
#define pinpulsaI A0
#define pinpulsaD A1
Si pulsamos a izquierda o derecha, sumaremos 1 a la cifra correspondiente, hasta que esta llegue a un valor mayor que 9, en cuyo caso se le obligará a tomar el valor 0.
Bluetooth
Para manejar el artefacto a distancia dispondremos de una aplicación para android que nos ofrecerá distintas posibilidades.
Como he mencionado en apartados anteriores, el uso del BT con los sensores ultrasónicos acarreaba problemas que no he estado dispuesto a averiguar. Así pues, cuando los sensores ultrasónicos están en funcionamiento en el modo automático, el BT permanecerá desconectado de alimentación. Es por esto que las conexiones pueden carecer de sentido para el lector que no haya seguido mi planteamiento hasta ahora.
Conectaremos la alimentación del Módilo HC-05 al pin digital D12 que será el encargado de suministrarle corriente en cuanto el modo de funcionamiento sea Manual y dejará de hacerlo en el momento que se pase a modo Auto.
Y los demás pines del módulo irán así:
- Tx del módulo BT irá a D10
- Rx del módulo BT se conectará a D11
- Vcc del módulo BT conectado a D12
- GND del módulo a GND del sistema.
Nótese lo natural para conectar en Serie el Módulo BT y arduino sería usar los pines D0 y D1 de arduino que están especialmente diseñados para ello, pero como imagino que sabrán, esto impediría poder programar el microcontrolador mientras esté usado el Rx de arduino. Por este motivo he decidido emplear otros pines para ello puesto que al estar el módulo integrado dentro del aparato, sería un engorro tener que abrirlo para quitar el BT y así poder programar el microcontrolador en caso de querer hacer modificaciones o ajustes futuros.
Esto obliga a declarar la librería <SoftwareSerial.h> necesaria para sustituir el uso de estos pines por otros (D11,D12).
#include <SoftwareSerial.h>
Para configurar el HC-06 o HC-05 podemos consultar este estupendo tutorial sobre el tema usando comandos AT. Así podemos cambiar su forma de trabajo, velocidad, nombre, contraseña y demás parámetros internos del módulo.
Aplicación para móvil Android por Bluetooth
Como he mencionado en apartados anteriores, el modo manual del contador desactiva la lectura de distancia de ultrasonidos y permite el manejo de los dígitos con el botón pulsador y el Bluetooth mediante la aplicación para móvil que describiré a continuación.
Mit App Inventor 2
La aplicación se ha realizado con el editor para Android conocido como Mit App Inventor2.
Es un lenguaje de programación por bloques fácil de entender.
Consta de un botón en la parte superior, que presionaremos para vincular con el HC-05 del contador entre los detectados por el dispositivo.
Más abajo aparecen los botones + y- para aumentar o disminuir puntos a cada equipo. Un botón central que apaga todos los leds.
Un botón para iniciar una cuenta progresiva que podemos parar en cualquier momento volviendo a pulsar de nuevo el botón. Esta cuenta mostrará los números como decenas y unidades, así solo llegará hasta 99.
Otro botón para iniciar una cuenta descendente con intervalos de segundos partiendo desde el número que se tenga en pantalla en ese momento (usar botones + -) hasta llegar al 00. Se tratarán estos valores como decenas y unidades. (inicio máximo desde 99).
Un último botón para realizar el conocido juego del pañuelito que muestra aleatoriamente un valor a cada dígito entre los máximos designados en la aplicación.
PCB de control para Arduino
Para colocar el cerebro de control, usaremos una PCB diferente, esto nos facilitará el ensamblaje del invento. Se puede realizar a mano siguiendo el esquema de conexiones, pero si dispones de placas de cobre y CNC este archivo te puede servir para evitar soldaduras y dar un aspecto algo más profesional.
Nótese que la escala no corresponde con las medidas reales, pues están exportadas con un valor de x2’5. Es por esto que habría que reajustarlas en el programa de fresado a una escala un 160%.
Tener en cuenta que he decidido separar de la placa central el módulo de BT, me parecía más adecuado. Hay una zona dispuesta para colocarlo a parte.
Piezas finales
Por último imprimir las piezas que faltan del cuerpo central y la tapa inferior del contador donde irá atornillada la PCB del bluetooth y del arduino, descarga el fichero STL.
Sketch
/**********************************************/
/* CONTADOR CON DOS 7 SEGMENTOS PARA EL COLEGIO MARE NOTRUM */
/* AUTOR: Pedrajas 2020 */
/**********************************************/
#include <SoftwareSerial.h>
#include <NewPing.h>
unsigned long pingTimer; // Holds the next ping time.
unsigned long paso;
const int dataPin = 2; // Pin conectado al Pin 14 del 74HC595 (Data)
const int latchPin = 3; // Pin conectado al Pin 12 del 74HC595 (Latch)
const int clockPin = 4; // Pin conectado al Pin 11 del 74HC595 (Clock)
#define TRIGGER_PIN 5 // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN 6 // Arduino pin tied to echo pin on the ultrasonic sensor.
#define TRIGGER_PIN2 7 // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN2 8 // Arduino pin tied to echo pin on the ultrasonic sensor.
SoftwareSerial BT1(10, 11); // RX | TX
#define BT 12
#define pinpulsaI A0
#define pinpulsaD A1
#define interruptor A2
#define MAX_DISTANCE 120 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.
int minimo = 3;
int maximo = 100;
NewPing sonarD(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
NewPing sonarI(TRIGGER_PIN2, ECHO_PIN2, MAX_DISTANCE);
boolean estadoI; ////// boton central
boolean estadoD;
boolean antesI = 0;
boolean antesD = 0;
boolean leoI;
boolean leoD;
boolean pasoI;
boolean pasoD;
boolean apagado = false;
// Strings para los datos transmitidos por el Bluetooth
String str = "";
const char separator = ',';
const int dataLength = 3;
int data[dataLength];
boolean manual;
int ultimoestado = 3;
boolean lectura;
// Pausa para niño que pasa por ultrasonido.
unsigned long lastDebounceTimeD = 0; // Se activa al pasar un objeto por el ultrasonido y lo deja libre.
unsigned long lastDebounceTimeI = 0;
unsigned long debounceDelay = 2000; // Retardo de un niño bloqueando el sensor ultrasonico. (700 parece bien)
unsigned long segundo = 1000;
unsigned long contador = 0;
// 7 segemntos dígitos
const byte dos[11] = {
0b01111011,
0b00100010,
0b01011110,
0b01101110,
0b00100111,
0b01101101,
0b01111101,
0b00101010,
0b01111111,
0b01101111,
0b00000000,
};
const byte uno[11] = {
0b01110111,
0b00000110,
0b00111101,
0b00011111,
0b01001110,
0b01011011,
0b01111011,
0b00010110,
0b01111111,
0b01011111,
0b00000000,
};
int unidad = 0;
int decena = 0;
void setup() {
Serial.begin(9600);
Serial.println ("Saludos");
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode (pinpulsaI, INPUT_PULLUP);
pinMode (pinpulsaD, INPUT_PULLUP);
pinMode (interruptor, INPUT_PULLUP);
pinMode (BT, OUTPUT);
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, dos[0]);
shiftOut(dataPin, clockPin, LSBFIRST, uno[0]);
digitalWrite(latchPin, HIGH);
pingTimer = millis(); // Start now.
BT1.begin(9600);
digitalWrite (BT, HIGH);
}
void loop() {
lectura = digitalRead (interruptor);
if (lectura != ultimoestado) {
if (lectura == HIGH) {
manual = 1;
digitalWrite (BT, HIGH);
Serial.println ("manual");
}
else
{
manual = 0;
Serial.println ("Auto");
digitalWrite (BT, LOW);
}
muestra(10, 10);
delay(500);
ultimoestado = lectura;
unidad = 0;
decena = 0;
muestra(decena, unidad);
}
if (manual == 1) { //Palanca en manual
if (BT1.available() > 0) { //en caso de recibir datos BT
str = BT1.readStringUntil('\n');
//Serial.println (str);
for (int i = 0; i < dataLength ; i++)
{
int index = str.indexOf(separator);
data[i] = str.substring(0, index).toInt();
str = str.substring(index + 1);
}
if (data[0] == 1) //lee el primer valor del BT (es 1--> Botones de añadir y quitar puntos a equipos)
{
if (data[1] == 1) {
decena = decena + 1;
if (decena > 9) {
decena = 0;
}
}
if (data[1] == 2) {
decena = decena - 1;
if (decena < 0) {
decena = 9;
}
}
if (data[1] == 3) {
unidad = unidad + 1;
if (unidad > 9) {
unidad = 0;
}
}
if (data[1] == 4) {
unidad = unidad - 1;
if (unidad < 0) {
unidad = 9;
}
}
muestra(decena, unidad);
apagado = false;
}
if (data[0] == 2) { //lee el primer valor (es 2---> botón de apagar dígitos.)
unidad = 0;
decena = 0;
muestra(10, 10);
apagado = true;
}
if (data[0] == 3) { //lee el primer valor (es 3) botón de --> INICIAR CUENTA A DELANTE.
contador = millis();
muestra(decena, unidad);
apagado = false;
data [0] = 0;
while (data[0] != 3 && data[0] != 2) {
if (BT1.available() > 0) { //en caso de recibir datos BT
str = BT1.readStringUntil('\n');
//Serial.println (str);
for (int i = 0; i < dataLength ; i++)
{
int index = str.indexOf(separator);
data[i] = str.substring(0, index).toInt();
str = str.substring(index + 1);
}
}
if (data[0] == 2) {
unidad = 0;
decena = 0;
muestra(10, 10);
apagado = true;
}
if ((millis() - contador) > segundo ) { //cada segundo suma una unidad.
unidad = unidad + 1;
contador = millis();
if (unidad > 9) {
unidad = 0;
decena = decena + 1;
}
if (decena > 9) {
decena = 0;
}
muestra(decena, unidad);
apagado = false;
}
}
}
if (data[0] == 4) { //lee el primer valor (es 4--- botón de ---> cuenta atrás)
data [0] = 0;
if (apagado == false) {
muestra(10, 10);
apagado = true;
delay (1000);
contador = millis();
muestra(decena, unidad);
apagado = false;
while (unidad != 0 || decena != 0) {
if ((millis() - contador) > segundo ) { //cada segundo resta una unidad.
unidad = unidad - 1;
contador = millis();
if (unidad < 0) {
unidad = 9;
decena = decena - 1;
}
if (decena > 9) {
decena = 0;
}
muestra(decena, unidad);
apagado = false;
}
muestra(decena, unidad);
apagado = false;
}
}
}
if (data[0] == 5) { //lee el primer valor (es 5 botón de ->> pañuelito)
unidad = 10;
decena = 10;
apagado = true;
muestra(decena, unidad);
delay (1000);
int contar2 = data[1];
decena = contar2 / 10;
unidad = contar2 % 10;
decena = random(decena + 1);
unidad = random(unidad + 1);
muestra(decena, unidad);
apagado = false;
}
}
//////////////////////////////////////////////////////////////// Rutina de los botones.
leoI = digitalRead (pinpulsaI);
leoD = digitalRead (pinpulsaD);
if (leoI == false && estadoI == 0) {
decena = decena + 1;
if (decena > 9) {
decena = 0;
}
estadoI = 1;
muestra(decena, unidad);
delay (150);
}
if (leoI == true && estadoI == 1) {
estadoI = 0;
delay (150);
}
if (leoD == false && estadoD == 0) {
unidad = unidad + 1;
if (unidad > 9) {
unidad = 0;
}
estadoD = 1;
muestra(decena, unidad);
delay (150);
}
if (leoD == true && estadoD == 1 ) {
estadoD = 0;
delay (150);
}
}
if (manual == 0) { // Si la palanta está en sensores de ultrasonidos.
sonar1();
}
}
void sonar1() {
delay(30);
int distanciaD = sonarD.ping_cm();
int distanciaI = sonarI.ping_cm();
if (distanciaD >= minimo && distanciaD <= maximo && pasoD == false)
{
pasoD = true;
unidad = unidad + 1;
if (unidad > 9) {
unidad = 0;
}
muestra(decena, unidad);
Serial.print(decena);
Serial.print(unidad);
Serial.print ("<-----");
Serial.println (distanciaD);
lastDebounceTimeD = millis();
}
if (distanciaI >= minimo && distanciaI <= maximo && pasoI == false)
{
pasoI = true;
decena = decena + 1;
if (decena > 9) {
decena = 0;
}
muestra(decena, unidad);
Serial.print(decena);
Serial.print(unidad);
Serial.print ("----->");
Serial.println (distanciaI);
lastDebounceTimeI = millis();
}
if (distanciaI == 0 || distanciaI >= maximo) {
if ((millis() - lastDebounceTimeI) > debounceDelay ) {
pasoI = false;
// Serial.println ("IFalse");
}
}
if (distanciaD == 0 || distanciaD >= maximo) {
if ((millis() - lastDebounceTimeD) > debounceDelay ) {
pasoD = false;
// Serial.println ("DFalse");
}
}
// Serial.println (distanciaI);
// Serial.println (distanciaD);
}
void muestra (int d, int u) {
delay (10);
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, dos[d]);
shiftOut(dataPin, clockPin, LSBFIRST, uno[u]);
digitalWrite(latchPin, HIGH);
}En el archivo se incluyen las librerías necesarias.
Ensamblaje
Al cerrar usar tornillos de 2.5mm. La alimentación se realiza con una power banks para móvil de 5V con conector lateral DC e indicador de polaridad.
Anabel
22 de febrero de 2021 — 21:56
Eres un genio, geniero!!!
javi
23 de febrero de 2021 — 16:32
Grande amigo! de dónde salió el nombre de la web? jajajaj
pascual
10 de junio de 2021 — 20:00
Hola muy bueno tu circuito , me podrías mandar la plantilla , me refiero al circuito impreso tipo rombo donde se conecta los 4 diodo leds , te dejo mi correo pascualpalacios525@gmail.com
Afelio
26 de junio de 2021 — 18:31
Los diodos leds no están sobre ninguna PCB ni placa de soldadura. Están anclados a la carcasa con forma de rombo y soldadas las patas de los diodos entre ellas mismas.
Observa que la forma de la pieza (con forma de rombo) permite que los diodos led se queden sujetos por su propia presión, además está el hueco para que entren las patillas de las resistencias.
pascual
1 de julio de 2021 — 07:11
Hola me gusta tu circuito , una consulta en los segmentos utilizas los diodos en serie , yo visto otros circuito de display con leds y están conectados los diodos led en paralelo , eso da igual.
jl
7 de noviembre de 2022 — 16:13
Muy bueno y claro todo el tutorial, felicidades. Yo tengo similar proyecto, pero leds en paralelo (necesito mucha luminosidad) para marcador de tiempo deportivo y por batería.
Mi problema ahora es la I, cómo logro (teniendo 9 leds x segmento), tanta intensidad? pues un dígito mostrando el 8, serían en mi caso 9leds*0,3mA*7segm.
gracias, acepto ideas 😉