Arduino: Display de 7 segmentos y como crear un dado electrónico

20/03/18 Display7 segmentos ycómo crear un dado electrónico DIY
https://programarfacil.com/blog/arduino-blog/display-7-segmentos-dado/ 1/19
Buscar en este sitio …
Estás aquí: Inicio/Blog/Arduino/Display 7 segmentos y cómo crear un dado electrónico DIY
Display 7 segmentos y cómo crear un dado electrónico DIY
Comentarios(17)
Luis del Valle Hernández
Cuando creamos un proyecto con Arduino, normalmente mostramos los datos a través del
monitor serie. Es una manera rápida de poder comprobar los valores de variables y entradas,
tanto digitales como analógicas. Existen diferentes interfaces hardware que permiten que las
máquinas se comuniquen con nosotros. Una de ellas es el display 7 segmentos, un
componente muy típico. Pero podemos encontrar otros como un LCD o una matriz de LEDs.
En este artículo te voy a explicar como utilizar un display 7 segmentos con Arduino. Vamos
a verlo con un caso práctico, crearemos un dado electrónico que nos permita seleccionar un
 CURSOS BLOG PODCAST ¿QUIÉN SOY? CONTACTAR
 ACCEDER
Política de cookies

número al azar entre 6 posibles.
Esto lo mostraremos en el display LED 7 segmentos con Arduino. Aprenderás todo lo que
necesitas saber sobre este componente, veremos cómo programarlo y descubrirás a obtener
números aleatorios desde el código nativo de Arduino.
Indice de contenidos
1 Display 7 segmentos, el componente electrónico
2 Analizando el display de 7 segmentos
3 Componentes necesarios para el dado electrónico
4 Display 7 segmentos y pulsador, montando el circuito
5 Programando el dado eléctrico con el display 7 segmentos
6 Código completo
7 Conclusión
Display 7 segmentos, el componente electrónico
Siempre que nos enfrentemos a un nuevo componente, es recomendable documentarse.
Para ello tenemos las hojas de características técnicas o datasheet. Todo dependerá del
modelo de display LED 7 segmentos. Pero, ¿cómo puedes saber que modelo tienes?
Todos los componentes suelen tener una numeración inscrita en alguna parte.
Solo tenemos que descubrirla y meter esa numeración en Google seguido de datasheet.
Esto nos mostrará una serie de páginas donde encontramos información muy valiosa. En mi
caso el display 7 segementos es el 5101AS.

De los resultados obtenidos nos vamos a uno de ellos (preferible buscar en algún PDF) y
miramos que características tiene este componente. Pero ojo, no nos debemos fiar siempre
de lo que nos diga Google. En algunos casos, encontramos cosas que están erróneas.
Analizando el display de 7 segmentos
Un display 7 segmentos es un componente que tiene 7 segementos LEDs, más un LED
que hará de punto. Este punto nos indica cómo hay que colocar el display, y siempre irá
hacia abajo. Por lo tanto, debemos trabajar como si tuviéramos 7 LEDs conectados a nuestro
Arduino.
Existen dos tipos de displays de 7 segmentos, los de ánodo común y los de cátodo
común. Esto quiere decir que en los primeros, todos los LEDs comparten un mismo
ánodo, y en los segundos, que todos los LEDs comparten un mismo cátodo. Veremos
más adelante un esquema de cada uno de ellos y cómo identificarlos.
Relación pines del display de 7 segmentos con los LEDs
Dentro del datasheet, encontrarás un dibujo parecido al que te muestro a continuación.
 Hay varias páginas donde nos ofrecen fichas técnicas de componentes. Dos de las más
famosas son Datasheet Catalog y All Datasheet.

Identifica cada segemento LED con una letra. Así tenemos identificados cada uno de ellos.
Este componente tiene 10 pines. Antes de hacer ninguna conexión debemos identificar los
pines.
Ahora lo único que nos falta es asociar cada pin a cada segmento LED. En la siguiente
imagen puedes ver esa relación.
 Fíjate bien que el punto siempre va hacia abajo

Podemos resumir todo lo anterior en la siguiente tabla.
Pines Segmentos
1 e
2 d
4 c
6 b
7 a
9 f
10 g
¿Y qué pasa con el resto de pines? Nos quedan por saber qué hacer con los pines 3, 5 y
8. ¿Te acuerdas que hemos visto que hay un punto para indicar la orientación del display
7 segmentos?, pues este va conectado al pin número 5.
Los otros dos pines funcionarán como cátodo o ánodo, dependiendo del tipo de display
de 7 segementos con el que estemos trabajando. Solo debemos utilizar una de esas dos
conexiones, se trata de pines redundantes.
Al final, la tabla que relaciona los pines con los LEDs quedaría de la siguiente manera.

Pines Segmentos
1 e
2 d
3 ánodo/cátodo común
4 c
5 DP (punto)
6 b
7 a
8 ánodo/cátodo común
9 f
10 g
Bueno, pues ya tenemos relacionados los pines con los segmentos (circuito eléctrico interno),
ahora vamos a ver cómo mostrar un número en el display de 7 segmentos.
Mostrando un número en el display 7 segmentos
Para poder mostrar un número en el display 7 segmentos, lo que tenemos que hacer es
iluminar aquellos segmentos para formar dicho número. Por ejemplo, si queremos
mostrar el 4, debemos activar los segmentos f, g, b y c y desactivar el resto de segmentos.

Como estos tienen una relación con los pines de Arduino, solo tendríamos que poner en
estado alto (HIGH) o bajo (LOW) esos pines (en la siguiente sección veremos los tipos de
displays que tenemos a nuestra disposición). Todo esto lo haremos a nivel de programación.
En el ejemplo de código, podrás ver cómo se hace.
Ánodo común o cátodo común, los dos tipos de display de 7
segmentos
Un diodo funciona de una manera muy particular, solo permite fluir la corriente a
través de él en un sentido, de ánodo a cátodo. Un LED no deja de ser un diodo con otra
particularidad, que emite luz. Ya lo vimos en el ejemplo dónde creábamos un semáforo
inteligente con múltiples LEDs.
Un display 7 segmentos funciona de la misma manera, vamos a tener ánodos y cátodos, en
concreto 8. Veamos el esquema eléctrico de los dos tipos de displays.

En mi caso, el 5101AS es un display de ánodo común. Pero si no estamos seguros de qué
tipo de display tenemos entre mano, podemos hacer una simple prueba.
¿Cómo saber el display 7 segmentos que tengo?
La prueba es sencilla. Para saber si es de ánodo común lo único que tenemos que hacer es
poner el pin 3 o pin 8 a la alimentación de 3,3 V o 5 V (poner una resistencia de 220 Ω en
serie, luego veremos porqué), y el pin número 5 (DP punto) a tierra (pin GND de nuestro
Arduino).
Si lo que tenemos un display ánodo común, la corriente pasará y se iluminará el punto. Si
tenemos un display del tipo cátodo común, no se encenderá el LED (recuerda que en un LED
la corriente solo fluye en un único sentido).
Dependiendo del resultado, sabremos el tipo de display de 7 segmentos que tenemos.
Voltaje de operación del display de 7 segmentos
Ya por último, debemos conocer el voltaje de operación del componente. Esto deberíamos
de verlo en la hoja de característica técnicas de cada modelo. Lo típico es que funcione
entre 1,8 V y 2,2 V (funcionamiento normal de un LED). Utilizando la Ley de Ohm, podemos
calcular la resistencia que necesitamos para los dos casos, el mínimo (1,8 V) y el máximo (2,2
V).
Para el voltaje de 1,8 V:
Para el voltaje de 2,2 V:

Componentes necesarios para el dado electrónico
Ya hemos visto cómo funciona el display 7 segmentos. Lo tenemos todo claro para poder
conectarlo a la protoboard y empezar a trabajar. Antes de ver las conexiones vamos a dar un
repaso por el material que vamos a utilizar para crear el dado electrónico.
Arduino UNO
Protoboar (placa de prototipado)
Cables para hacer conexiones
1 pulsador
1 resistencia de 10 kΩ
1 resistencia de 220 Ω
1 display de 7 segmentos
Display 7 segmentos y pulsador, montando el
circuito
Vamos a montar el circuito de un display de 7 segmentos con un pulsador. Te voy a dejar las
dos configuraciones, para cátodo común y para ánodo común.
Cátodo común
 Siempre y cuando el voltaje no supere el máximo, podemos alimentar el LED. Por lo tanto,
si ponemos una resistencia mayor lo único que sucederá es que el LED iluminará
menos.

Ánodo común
Programando el dado eléctrico con el display 7
segmentos
Comenzamos con la programación. En términos de lógica, da lo mismo tener un display 7
segmentos en configuración de cátodo común que ánodo común. Donde si que encontraremos
diferencias es a la hora de implementar la lógica.
Comenzaremos con el algoritmo, una breve descripción de los pasos que debemos seguir. Es
recomendable plantear las ideas antes de ponerse a programar.
1. Leemos el pulsador
1. Si está en estado alto
1. Obtenemos número aleatorio
2. Mostramos el número en el display
3. Esperamos un tiempo hasta permitir otra jugada
2. Si está en estado bajo
1. No hacemos nada
 Como ves en las imágenes anteriores, no hay gran diferencia. Solo la conexión del pin
número 3. En cátodo común va a tierra (GND) y en ánodo común va a la fuente (5 V).
Donde si veremos diferencia es a la hora de programar.
 El pulsador siempre debe ir acompañado de una resistencia pull down o pull up.
Dependerá del estado que queramos tener cuando la conexión con la entrada digital esté al
aire.

Es un código muy sencillo. Quizás, donde encontremos más dificultad, sea a la hora de mostrar
los números en el display. Eso lo veremos ahora.
Variables y constantes
Comenzamos con una buena práctica. Declarar todas las constantes que relacionan los
pines con los componentes. En este caso solo vamos a declarar una constante, el pulsador.
Para los pines del display 7 segementos, vamos a utilizar un array multidimensional. Lo
primero es saber qué es un array o matriz. Este tipo de variables nos permite agrupar
datos del mismo tipo.
Cuando hablo de array multidemensional, quiero decir que tendremos un array de arrays.
Es sencillo, cada elemento del array principal es otro array. En este caso tendremos
profundidad de 2, pero podríamos tener más profundidad.
Este tipo de arrays, donde tenemos 2 dimensiones, lo podemos ver como una tabla. Para
acceder a un elemento tenemos que indicar la fila y la columna donde se encuentra dicho
elemento. Esto viene indicado por el valor entre corchetes [columna] [fila].
En este caso crearemos un array con 10 elementos que serían los 10 números posibles,
del 0 al 9. Cada elemento contendrá 1 array de 8 elementos que serían los pines a los
que está conectado el display de 7 segmentos (7 para cada segmento y el punto).
Función setup
En esta función tenemos que establecer las condiciones iniciales. Lo primero es iniciar el
 Este array solo sirve para cátodo común. Si tenemos el otro tipo de display 7 segmentos,
debemos cambiar los unos por los ceros y los ceros por unos.
1
2
// Constantes pines
#define PULSADOR 10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Array multidimensional para mostrar los números
byte numero[10][8] =
{
{ 1, 1, 1, 1, 1, 1, 0, 0 }, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0 }, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0 }, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0 }, // 3
{ 0, 1, 1, 0, 0, 1, 1, 0 }, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0 }, // 5
{ 1, 0, 1, 1, 1, 1, 1, 0 }, // 6
{ 1, 1, 1, 0, 0, 0, 0, 0 }, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0 }, // 8
{ 1, 1, 1, 0, 0, 1, 1, 0 } // 9
};

monitor serie.
Luego seguimos con los segmentos del display. Hay que poner todos los pines donde está
conectado (del 2 al 9) en modo salida (OUTPUT). Podemos hacerlo de dos maneras,
hacerlo de uno a uno o con un bucle. La dificultad de este bucle es que no debemos empezar
por el cero. Los pines que utilizamos son del 2 al 9, haremos un bucle que recorra todos
estos números.
Dentro utilizaremos la variable del bucle como número de pin. Es muy sencillo, lo puedes
comprobar a continuación.
A continuación, el pin del pulsador lo ponemos en modo entrada.
Por último, establecemos la semilla fija para obtener el valor aleatorio a través de la función
random. Esta semilla será una entrada analógica.
Función loop
Ahora vamos con la parte que se repite constantemente. Como hemos visto en la descripción
del algoritmo, lo primero es leer el pin digital donde tenemos conectado el pulsador. Luego
comprobamos si está en estado alto (pulsado).
 Como semilla, elegir un pin analógico que no se utilice. Como ya hemos visto con el
pulsador, no establecer una resistencia pull down o pull up produce una indeterminación.
Esto nos permitirá seleccionar un número aleatorio verdadero.
1
2
3
void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);
1
2
3
4
5
// Ponemos los pines de los segmentos en modo OUTPUT (salida)
for (int i = 2; i < 10; i++)
{
pinMode(i, OUTPUT);
}
1
2
// Ponemos el pin del pulsador en modo INPUT (entradda)
pinMode(PULSADOR, INPUT);
1
2
3
//Establecemos la semilla fija
randomSeed(analogRead(A0));
}
1
2
3
4
5
6
7
void loop() {
// Leemos el valor del pulsador
int valor = digitalRead(PULSADOR);
// Si está pulsado
if (valor == HIGH)
{

Una vez que estemos seguro que se ha pulsado es cuando empezamos la secuencia de
obtener un número aleatorio entre 1 y 6, con la función random, y mostramos el número que ha
salido. La función random(min, max) admite dos parámetros el mínimo y el máximo.
Este máximo es exclusivo lo que quiere decir que debemos elegir el número entero superior
al número máximo que queremos elegir. En nuestro caso sería random(1,7) para elegir un
número entre 1 y 6.
Voy a describir el funcionamiento del bucle. Al final, para mostrar un número en el display, lo
que tenemos que hacer es encender un LED y apagar los demás.
Por ejemplo, si queremos encender el número 1, tenemos que ir al elemento 1 (recuerda que
antes hay otro elemento que es el elemento 0. Será el array con 8 valores).
El primer elemento indica el primer LED (corresponde con la letra e y el pin 2). Por lo tanto, el
pin 2 al valor que nos indica el array, 0 V (LOW).
El siguiente elemento es el pin 3 (letra c), lo tenemos que poner a nivel alto 5 V (HIGH). Y así
con todos los elementos.
El orden nos dirá el pin (hay que sumar dos ya que hemos empezado a conectar por el pin 2) y
el valor nos dirá en que estado 0 (LOW) y 1 (HIGH).
Código completo
A continuación te dejo todo el código para que lo puedas copiar fácilmente.
1
2
3
4
5
6
7
8
9
10
11
12
//Genera un numero aleatorio entre 1 y 6
int randomNumber = random(1, 7);
// Ponemos los pines en estado correcto para mostrar el número randomNumber
for (int e = 0; e < 8; e++)
{
digitalWrite(e + 2, numero[randomNumber][e]);
}
delay(500);
}
}
1 { 0, 1, 1, 0, 0, 0, 0, 0 }
1
2
3
4
5
6
7
8
9
10
// Constantes pines
#define PULSADOR 10
{
{ 1, 1, 1, 1, 1, 1, 0, 0 }, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0 }, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0 }, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0 }, // 3

Conclusión
Una de las ventajas que tenemos de mostrar la información con un display de 7 segmentos, es
que es muy sencillo y vistoso. Aquí hemos visto un ejemplo para mostrar un número del 1 al 6.
Resultaría muy sencillo modificar este ejemplo y utilizarlo para otro proyecto.
Te animo a que lo hagas y me mandes tus resultados. Estaría encantado de verlos :).
Recuerda, si te ha gustado comparte y si tienes alguna duda lo puedes poner en los
comentarios de este artículo.
Gracias a Shutterstock por ceder los derechos de la imagen
20 Comentarios Programar Fácil con Arduino Acceder

1
Compartir
⤤ Ordenar por los mejores
Únete a la conversación...
• Responder •
Joaquin Suarez Bendezu • hace 2 meses
Hola, mi display es de cátodo común, y aunque hice el circuito y código del cátodo común, el display me
muestra los números incompletos, por ejemplo a el ocho le falta dos rayas.
¿Cómo lo arreglo?
△ ▽
Luis del Valle • hace 2 meses
Moderador > Joaquin Suarez Bendezu
Recomendar
 1
Compartir ›
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
{ 0, 1, 1, 0, 0, 1, 1, 0 }, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0 }, // 5
{ 1, 0, 1, 1, 1, 1, 1, 0 }, // 6
{ 1, 1, 1, 0, 0, 0, 0, 0 }, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0 }, // 8
{ 1, 1, 1, 0, 0, 1, 1, 0 } // 9
};
void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);
// Ponemos los pines de los segmentos en modo OUTPUT (salida)
for (int i = 2; i < 10; i++)
{
pinMode(i, OUTPUT);
}
// Ponemos el pin del pulsador en modo INPUT (entradda)
pinMode(PULSADOR, INPUT);
//Establecemos la semilla fija
randomSeed(analogRead(A0));
}

• Responder •
Moderador > Joaquin Suarez Bendezu
Hola Joaquín, comprueba bien las conexiones es algo típico en este proyecto. Luego asegúrate
que es realmente de cátodo común.
△ ▽
• Responder •
bermudezarreola01 • hace 4 meses
Hola, copié y pegue el código y sin problema compiló. Al ejecutar, si bien hay cambios en el display no se
forman números cada que pulso el botón, incluso hasta el punto llega a encender, lo que me genero una
duda, ¿porqué conectar la pata correspondiente al punto (salida 8 a borne 5) si éste no formaría parte de
los números del dado?.
Mi display es de ánodo común, use R1 de 220 ohms y R2 de 10 kohms, verifique varias veces las
conexiones del circuito.
También pulse varias veces hasta comprobar que todos los leds del display encienden.
Gracias.
△ ▽
• Responder •
CARLOS ANDRES ZAPATA DAGUA • hace 3 meses
> bermudezarreola01
Para ánodo común utiliza este codigo
{ 0, 0, 0, 0, 0, 0, 1, 1 }, // 0
{ 1, 1, 1, 1, 0, 0, 1, 1 }, // 1
{ 0, 0, 1, 0, 0, 1, 1, 0 }, // 2
{ 1, 0, 1, 0, 0, 0, 1, 0 }, // 3
{ 1, 1, 0, 1, 0, 0, 1, 0 }, // 4
{ 1, 0, 0, 0, 1, 0, 1, 0 }, // 5
{ 0, 0, 0, 0, 1, 0, 1, 0 }, // 6
{ 1, 1, 1, 0, 0, 0, 1, 1 }, // 7
{ 0, 0, 0, 0, 0, 0, 1, 0 }, // 8
{ 1, 0, 0, 0, 0, 0, 0, 0 } // 9
△ ▽
• Responder •
Moderador > CARLOS ANDRES ZAPATA DAGUA
Gracias por el aporte Carlos, seguro que a más de uno le sirve para conectar su display
de 7 segmentos para ánodo común.
△ ▽
• Responder •
Moderador > bermudezarreola01
Hola, revisa bien las conexiones. El pin 5 del display de 7 segmentos y el pin 8 de Arduino se
conectan juntos para poder controlar el encendido y apagado del display de 7 segmentos con
Arduino. Nivel LOW apagado y nivel HIGH en alguno de los pines muestra un número. Como ya
te he comentado revisa bien las conexiones.
△ ▽
• Responder •
Valentina asdfghjkl • hace 4 meses
Le he intentado de todas las formas, eso no me da.Ayuda por favor !!!
△ ▽
• Responder •
Moderador > Valentina asdfghjkl
Hola Valentina si no nos dices cual es tu problema con el display de 7 segmentos difícilmente
podré ayudarte :)
△ ▽
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›

• Responder •
Valentina asdfghjkl • hace 4 meses
> Luis del Valle
De verdad tambien lo intente
en forma virtual con la pagina que usaste para moatrar el montaje. Porfavor me gustaria
hacerlo, cuando lo hice, no me muestra los numeros, me muestra cowas totalmente
diferentes
△ ▽
• Responder •
Moderador > Valentina asdfghjkl
Valentina es complicado con la descripción que me estás dando hacer una
valoración del problema que tienes con el Display de 7 segmentos. Yo te diría que
pruebes a revisar las conexiones y asegúrate si es cátodo común o ánodo común.
△ ▽
• Responder •
Manuel Suarez Delgado • hace 5 meses
ver más
Hola, tengo una duda de si el esquema de montaje del circuito esta mal echo o yo lo e echo mal pero me
a funcionado de otro modo.
⛺
△ ▽
• Responder •
Rafael Martinez • hace 4 días
> Manuel Suarez Delgado
HOLA, yo lo único que cambie del código fue el array y ya me funciono con display de cátodo
común 5611AS
{ 1, 1, 1, 1, 1, 1, 1 ,0 }, // 0
{ 0, 0, 0, 0, 1, 1, 0, 0 }, // 1
{ 1, 1, 0, 1, 1, 0, 1, 1 }, // 2
{ 0, 1, 0, 1, 1, 1, 1, 1 }, // 3
{ 0, 0, 1, 0, 1, 1, 1, 1 }, // 4
{ 0, 1, 1, 1, 0, 1, 1, 1 }, // 5
{ 1, 1, 1, 1, 0, 1, 1, 1 }, // 6
{ 0, 0, 0, 1, 1, 1, 1, 1 }, // 7
{ 1, 1, 1, 1, 1, 1, 1, 1 }, // 8
{ 0, 1, 1, 1, 1, 1, 1, 1 }, // 9
△ ▽
Compartir ›
Compartir ›
Compartir ›
Compartir ›

• Responder •
Luis del Valle • hace 2 días
Moderador > Rafael Martinez
Raro pero si te ha funcionado, perfecto :)
△ ▽
• Responder •
Moderador > Manuel Suarez Delgado
¿Qué tipo de display de 7 segmentos tienes? Hay display de siete segmentos cátodo común y
ánodo común. Comprueba cual tienes tu.
△ ▽
• Responder •
TubeAdicto • hace 8 meses
Hola, muy interesante tu tutorial.
Si quisiera poner un buzer para que suene cada vez que se usa el pulsador, que tendría que hacer?
Un saludo.
△ ▽
• Responder •
Moderador > TubeAdicto
Hola, para hacer eso tendrías que seguir este tutorial donde explico como utilizar un buzzer
https://programarfacil.com/...
△ ▽
• Responder •
Daniel Martínez Pérez • hace 9 meses
¿Qué tendría que cambiar para que me mostrase todos los números? (Del 0 al 9 ambos incluidos).
△ ▽
• Responder •
ver más
Moderador > Daniel Martínez Pérez
Hola Daniel, solo tendrías que recorrer el array número y mostrar de uno en uno. Te dejo el
código a continuación
{
{ 1, 1, 1, 1, 1, 1, 0, 0 }, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0 }, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0 }, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0 }, // 3
{ 0, 1, 1, 0, 0, 1, 1, 0 }, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0 }, // 5
{ 1, 0, 1, 1, 1, 1, 1, 0 }, // 6
{ 1, 1, 1, 0, 0, 0, 0, 0 }, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0 }, // 8
{ 1, 1, 1, 0, 0, 1, 1, 0 } // 9
};
void setup() {
△ ▽
• Responder •
luismg • hace un año
Muy buen tutorial, gracias
△ ▽
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›
Compartir ›

#126 ¿Arduino y ESP se unen? Proyectos que
salvan vidas y muchas cosas más
6 comentarios • hace 2 meses
Luis del Valle — Muchísimas gracias Jorge por
tus palabras, es un placer poder compartir con
estos dos monstruos un podcast. Respecto al
proyecto …
NodeMCU tutorial paso a paso desde cero
18 comentarios • hace 9 meses
Luis del Valle — Perfecto Kike, si te funciona a
esa velocidad mejor :)Depende el ejemplo, eso se
utilizaba antes pero ahora prueba a quitarlo para
…
Cómo conectar MQTT con ESP8266,
Raspberry Pi y Mosquitto
12 comentarios • hace un mes
Luis del Valle — Muchas gracias Mario por tus
comentarios y por el aporte. Todavía no he
probado Photon y espero algún día hacerlo con
MQTT ;)
Cómo utilizar el sensor DHT11 para medir la
temperatura y humedad con Arduino
18 comentarios • hace un año
Luis del Valle — No tiene porque ser de 5k una
de 10k valdría también.
TAMBIÉN EN PROGRAMAR FÁCIL CON ARDUINO
• Responder •
• Responder •
Luis del Valle • hace un año
Moderador > luismg
Gracias a ti lusmg ;)
△ ▽
Suscríbete
✉ Añade Disqus a tu sitio webAñade Disqus Añadir
d Privacidad
Compartir ›
Compartir ›

Cayenne myDevices y Arduino para
monitorizar sensores del IoT
Una de las plataformas que más prometen en el
panorama actual es Cayenne myDevices. Desde
hace tiempo la llevo siguiendo y poco a poco va
incorporando …
[+ info...]
#131 Programar con un Nokia 2690, en
ensamblador o en código máquina, tu
eliges
Bienvenido a este nuevo programa del podcast
La Tecnología Para Todos. Como ya habrás
oído en pasados capítulos, de vez en cuando nos
juntamos José …
[+ info...]
COPYRIGHT © 2018 · PROGRAMAR FÁCIL · AVISO LEGAL

Arduino: Display de 7 segmentos y como crear un dado electrónico

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Arduino: Display de 7 segmentos y como crear un dado electrónico

Similar a Arduino: Display de 7 segmentos y como crear un dado electrónico (20)

Más de SANTIAGO PABLO ALBERTO

Más de SANTIAGO PABLO ALBERTO (20)

Último

Último (20)

Arduino: Display de 7 segmentos y como crear un dado electrónico