bclose

Display de 7 segmentos

Mostrando informacion numérica

Objetivos

 

 

    • Nuestro primer display numérico de 1 digito.
    • Mas sobre los arrays.
 

Material requerido.

Imagen de Arduino UNO

 Arduino Uno o similar.

Esta sesión acepta cualquier otro modelo de Arduino.

 

Protoboard

 Una Protoboard.

conexiones

 Cables  de protoboard

componente

 Una resistencia.

BCD 1 digito Un display de 1 dígito.

 

Los displays LED

 

En cuanto empecéis a plantearos hacer un circuito que realice alguna función práctica, hay un 50% de probabilidades de que acabéis necesitando enviar información al mundo exterior (y claro no vais a dejar vuestro portátil pegado al invento).

Así que es el momento de ver que nos ofrece el mercado para mostrar información y para empezar, nada mejor que un sencillo display LED de 1 digito.

Los diodos LED ya no guardan secretos para los que nos siguen, pero esto de un display parece otra cosa.
Pues no. Es lo mismo pero en lugar de ser un punto luminoso como los familiares LED, tiene forma de barra: 7 barras más 1 punto.

Estos displays nos son bastante familiares en despertadores y similares, están formados por 7 líneas, que a dependiendo de qué segmentos  se iluminan, muestran los dígitos del 0 al 9.

A cada uno de los 7 segmentos se les adjudica una letra para representarlos y suele ser a, b, c, e, f, g y aparte un punto (o dos, o dos puntos según el fabricante) y es un buen momento para echar un vistazo a las especificaciones de cada fabricante para estar seguros de que pin es cual.

Todos los circuitos, los displays incluidos, llevan un código de fabricante rotulado. Es buena política buscar en internet la hoja de especificaciones(o data sheet) y echarle un ojo. Si no entendéis nada, es lo normal de momento, pero desde luego habrá un dibujo diciéndoos que es cada pin. Yo he buscado el modelo que tengo delante, (un Kingbright SC08-11HWA ), pero no os fieis, el vuestro puede ser distinto.

pinout patillaje
 
  • Desde que existe Internet, localizar una hoja de características es algo trivial (No como antes, que para conseguirlas había que pedir favores y mostrar las debidas muestras de respeto y sumisión a quien disponía de catálogos de componentes).
  • Probad a buscar en Google algo así como XXXXX data sheet, donde XXXXX son los códigos que habéis encontrado rotulado en el display o componente que sea.  

Lo importante es que sepáis que es cada pin, y que veáis que segmento es cual. En realidad es bastante más fácil de lo que parece, localizad primero un GND. En el de arriba son el 3, 5, 11 y 16.

Poned una resistencia (de 330Ω como siempre) de la salida del display a GND. Este es un display de cátodo común, o sea que todos los LEDS comparten la masa, pero necesitamos poner una resistencia de limitación o fundiréis el display, y este vale ya lo suficiente, como para que os cueste verle la gracia al tema.

Una vez que hayáis conectado la masa común con una resistencia, empezad cableando solo un LED, el a por ejemplo y conectadlo al pin 2 de Arduino. Escribid un programa en Arduino para iluminar el LED en el pin 2 y veréis como se enciende el segmento a.

Podéis ir conectando y probando el resto de los pines poco a poco, asegurando las conexiones. Es muy fácil equivocarse si no andáis con tiento.

 

Kit de Inicio Prometec.net 

Para los que uséis el nuevo kit de inicio de Prometec, el display que viene es un 5161AS que tiene un patillaje y cuyo diagrama es este:

patillaje del 6161AS

Para saber cual es el pin 1, poner el display de modo que viendo los numeros el punto decimal quede abajo a vuestra derecha. El pin numero 1 es en la parte inferior el primero por la izquierda, y luego ir contando en el sentido contrario a las agujas del reloj.

Numeracion de pines

 

 

Esquema eléctrico del circuito

 

Display 1 digito

El circuito no puede ser más sencillo, son como cuando hicimos un circuito con 8 diodos, solo que esta vez los 8 diodos están en una cajita y con forma para dibujar números.

 
  • Es importante que sigáis el esquema de aquí encima para que luego el programa coincida con vuestras conexiones.
  • Por eso no es importante que pin de vuestro display es el segmento C (Que dependerá del fabricante y modelo), pero si que es importante que el segmento C vaya al pin digital 4 de Arduino y lo mismo para los demás.  

No vamos a incluir el diagrama de protoboard, porque es difícil dejarlo más claro

Programa de control

 

Tenemos que comprobar que las conexiones son correctas lo primero. Probad esto:

void setup()
   {
        for (int i = 2; i<11; i++)
        pinMode(i, OUTPUT);
   }

void loop()
   {
        for ( int j= 2; j<11 ; j++)   // Va encendiendo los segmentos
           {
              digitalWrite(j, HIGH);
              delay(400) ;
           }
        for ( int j= 2; j<11 ; j++)   //Apaga todos los segmentos
              digitalWrite(j, LOW);
        delay(400) ;
   }

En el setup, inicializamos los 8 pines de salida con for (recordar que somos vagos) y en el loop usamos una primera iteración que va iluminando los 8 segmentos con un delay, y en la segunda los borra y vuelta a empezar. La idea es comprobar que las conexiones son correctas.Vereis algo así:

Lo siguiente es mostrar los dígitos del 0 al 9.

Para ello, lo más rápido es hacerte una tabla para ver que segmentos tienes que iluminar para cada digito decimal, y vas apuntando cuales son 1 (encendido) o 0 (apagado).

 DIGITOabcdefgpunto
 Nombres de segmentos011111100
101100000
211011010
311110010
401100110
510110110
610111110
711100000
811111110
911100110
 
  • Aunque os damos los deberes hechos, haced la prueba con alguno de los dígitos, simplemente, para aseguraros de que entendéis la idea
 

Ahora solo queda escribir el programa que dibuja los números en el display, así que vamos a ello.

Programa que dibuja los dígitos

 

La primera idea que se nos ocurre a todos es hacer una función por cada digito que queramos representar. Por ejemplo podríamos hacer:

void Display7()
   {
       digitalWrite(2, 1) ;        // Si, podemos decir 1 y 0 en lugar de HIGH y LOW
       digitalWrite(3,1);
       digitalWrite(4,1);
       digitalWrite(5,0);
       …………..
   }

Es decir, encendemos los pines correspondientes a cada segmento a imagen de la tabla previa.

El problema de este enfoque es que hay que hacer 10 funciones como esta y luego escribir en el programa principal algo que llame a la función correspondiente según el número que queramos mostrar.

Esta es, de nuevo, la solución de fuerza bruta y no, aquí no permitimos esas cosas, nos gustan las soluciones elegantes (y porque, además, somos muy vagos y nos cansamos solo de pensar en hacerlo así).

 
  • Por cierto, para ser alguien en la comunidad freaky, hay que hablar de la elegancia de tu código siempre que surja la ocasión, si queréis ser programadores es muy importante que empecéis a adoptar las poses del gremio. 
 

Así que vamos a buscar otra solución más elegante. Para empezar, todos los que al ver  la última tabla, con los segmentos que hay que iluminar, hayáis pensado que se parece sospechosamente a un array de 10 x 8 podéis anotaros un punto por listos.

Porque por supuesto vamos a crear una array con todo eso (No, no tenemos comisiones por vender los arrays) y veréis que el programa se simplifica mucho.

De nuevo, como con todo en la vida, es mucho más fácil de lo que parece. Vamos a empezar definiendo el array de dos dimensiones (porque es una tabla, otra cosa son el número de elementos por dimensión):

byte  Digit[10][8] =                // Arduino UNO va muy justo de memoria. Por eso lo
{                                   // definimos como byte y no como int
   { 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
};

Si os fijáis, he copiado directamente la tabla de mostrar los dígitos, pero en un array de 10 elementos, cada uno de los cuales es un array de 8(segmentos). La sintaxis es más o menos complicada, pero no hay más y esto ya lo habíamos hecho antes.

Podemos ahora crear una función, que pasándole un número de 0 a 9, elija la fila del array en función de ese mismo número y busque el array interno correspondiente.

void Display(int N)
   {
       for (int i= 0 ; i<8 ; i++)
            {   int valor = Digit[N][i] ;
                int pin = i+2;
                digitalWrite(pin , valor) ;
            }
   }

Buscamos  valor en la tabla cuyo índice principal N apunta al array interno correspondiente.  El for i, va leyendo los 8 elementos del array para escribirlos en el pin correspondiente de salida, que lo calculamos como i +2, (Porque usamos los pines 2 al 10 para conectar los segmentos del display y así unos valores de 1 de 0 a 8 se convierten en pines de 2 al 10).

void setup()
   {   for (int i= 2; i<11; i++)
            pinMode(i, OUTPUT);
   }

void loop()
   {
       for ( int k=0 ; k<10 ; k++)    // Llama a Display para k de 0 a 9, los digitos
         {  Display(k);
            delay(1000);
         }
   }

void Display(int N)
   {
      for (int i= 0 ; i<8 ; i++)
           {   int valor = Digit[N][i] ;
               int pin = i+2; 
               digitalWrite(pin , valor) ;    // digitalWrite(i+2 , Digit[N][i] ) ;
           }
   }

Fijaros que podíamos haber escrito así (El código compacto también puntúa con los colegas):

void Display(int N)
   {      for (int i= 0 ; i<8 ; i++)
               digitalWrite(i+2 , Digit[N][i] ) ;
   }

He aprovechado este ejemplo para insistir con los arrays, porque son muy útiles para resolver problemas que de otro modo se pueden complicar bastante.

Un problema que a priori, era muy pesado, o complejo, se transforma en una nimiedad recorriendo la tabla. He visto varios ejemplos por internet de este programa y la mayor parte de ellos me ha dado dolor de cabeza (Con algunas muy honrosas excepciones).

La cosa ha ido bastante bien con un digito, pero… ¿Y si queremos mostrar 4 dígitos? ¿Vamos a multiplicar 8 cables x 4 dígitos más tensión y GND = 34 pines?

En la próxima sesión veremos cómo manejar un display de 4 dígitos, porque para eso los venden hechos, y no es necesario volvernos locos enchufando no sé cuántos cables para hacer un reloj.

 
  • Como esta sesión ya es suficientemente densa, no incluiré el ejemplo de conectar un único digito a un shift register para gobernarlo, pero os recomiendo que lo hagáis como práctica, y si es preciso, colgamos el ejemplo en la página web.
 

 

 

Resumen de la sesión

 

 
    • Hemos presentado los displays LED de 7 segmentos y un dígito.
    • Son LEDs completamente normales, solo que en forma de líneas y no de puntos.
    • Algunas de las funciones que hemos definido nos seran útiles en los siguientes capítulos para gobernar mas display
 

 

 

 

(39) Comments

    • Will

    Tiene alguien el diagrama de protoboard de este laboratorio por favor?
    Gracias.

    • Jaime

    //AQUI os dejo mi version para que cuente el punto tambien XD
    void setup()
    { for (int i= 2; i<11; i++)
    pinMode(i, OUTPUT);
    }
    byte Digit[11][8] = // Arduino UNO va muy justo de memoria. Por eso lo
    { // definimos como byte y no como int
    { 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
    { 0,0,0,0,0,0,0,1 }, // punto
    };
    void loop()
    {
    for ( int k=0 ; k<11 ; k++) // Llama a Display para k de 0 a 9 y el punto
    { Display(k);
    delay(700);
    }
    }

    void Display(int N)
    { for (int i= 0 ; i<8 ; i++)
    digitalWrite(i+2 , Digit[N][i] ) ;
    }

    • Alex Valdez

    Hola. Tengo 2 dudas. La primera es en el for del void setup() donde pones: for (int i= 2; i<11; i++) para indicar q los pines son de salida segun yo haces de salida 9 pines ya que cumplen la condición cuando i=2,3,4,5,6,7,8,9 y 10. Pero solo el display ocupa 8 o me equivoco?
    Mi segunda duda es si puedo usar una resistencia de 220 ohms en lugar de una de 330 ohms para conectarla al GND? Y si debo conectar los 2 GND con dichas resistencias?
    Gracias por leer!

    • Hola Alex, tienes razón sería hacer nos sobra una iteración el el for. Por otra parte sí podrías usar la resistencia de 220, y sólo necesitas conectar uno de los GND. Saludos.

  • El dígito cuatro no se muestra correctamente
    { 0,0,1,0,0,1,1,0 }, // 4
    Debiera ser
    { 0,1,1,0,0,1,1,0 }, // 4

  • hola, primero que nada, muchas gracias por los tutoriales… pero creo que en el segundo ciclo for del primer codigo le faltan los { }

    • Hola Facundo! Si te fijas en el video lo que hace es apagar todos los segmentos a la vez y luego espera el tiempo del delay antes de volver a empezar. Si pusieses los {} apagaría uno a uno cada segmento en vez de todos a la vez. Un saludo!

    • Manuel

    hola no se si me puedan ayudar mi residencia es hacer un tablero digital deportivo para futbol con un arduino mega que consegi y displey de 7 segmentos controlado mediante una aplicacion bluetooth para este consegui un hc-05 y 06 pero no se como hacerlo q me aconsejas?

    • Hola Manuel, échale un ojo a estos tutoriales que hablan sobre los mñodulos bluetooth y si tienes dudas nos comentas. Un saludo.

    • Hola Manuel, no estoy muy seguro de que es lo que necesiats

    • Preto

    Hola admin, en primer lugar felicidades por la pagina me parece muy bien trabajada. He llegado a tu tutorial y tengo el mismo display que tu o por lo menos la data sheet es la misma pero siguiendo todos los pasos no me funciona, probando en alimentar el comun con 5V me funciona pero a la inversa, es decir los que deberian de estar apagados se encienden y viceversa tienes idea de porque puede suceder esto? Gracias de antemano!!

    • Hola Preto, tiene pinta de que estas utilizando un display similar, pero invertido. Es decir que los diodos que lo componene estas montados al reves. Cuando miras estos componentes suelen decirte que son de anodo comun (Comun el positivo y negativos independientes) o bien catodo comun (positivos independientes y gnd comun)

      • Entonces el mio debe de ser de anodo comun.He pobado a simplemente cambiar el HIGH por LOW y viceversa y funciona bien pero es este el metodo correcto que debo utilizar?

  • Saludos, tengo un display doble de siete segmentos de ánodo común, su pinout lo determiné con el método de prueba de energizarlo con una resistencia limitadora. Por suerte la utilicé primero colocandola precisamente en el ánodo y fuí ubicando segmento a segmento cada pin. Este display no cuenta con el pin DP. Mi pregunta es ¿Cómo puedo conectarlo para hacer un contador de 0 a 99 siendo de ánodo común, ya que la gráfica que has posteado es para displays de cátodo común. para el multiplexado dispongo de dos transistores BC549, ¿Me servirán para lo que quiero? Gracias de antemano por tu ayuda

    • Hola Jesus, no es facil responderte sin conocer el chip exacto y hacer pruebas pero ten en cuenta que al final es una custion de sentido comun y comprender un poco el modo de funcionamiento. No hay nada que no puedas entender en cuanto le dediques dos minutos

    • Agustin

    Hola, a ver si pueden ayudarme, tengo un display de 4 digitos 7 segmentos, estoy usando una libreria que encontre para utilizarlo, y quiero que me muestre las rpm que estoy midiendo con un sensor hall, pero logro que mustre las rmp en un parpadeo cada un segundo, supongo que el programa de medicion tarda e interfiere con la repeticion que necesita el display para que se vea claramente. Algun consejo??? Gracias

  • Me resulta la prueba de los segmentos incluso movi de posicion los pines de salida partiendo desde 4 solo por probar
    pero cuando compilo el siguiente ejemplo me aparece el siguiente error en el compilador arduino 1.6.9 ‘Display’ was not declared in this scope

    agradecería me aclarases entiendo que no esta declarado el array .

    • Hola Jorge, Parece que por lo que sea no incluyes la funcion Display en tu programa pero la puedes encontrar en lasesion tambien. COpiala y pegala en yu programa y ya esta

    • John David Molina

    Estimado Sr:
    Agradezco muchísimo su tutorial, su claridad para explicar. Estoy recién iniciándome en esto de Arduino, y si bien sé programar, recién estoy empezando a aprender algo de electrónica.

    Una de las cosas que me preocupa es no quemar nada (especialmente el Arduino). Por ello trato de entender la lógica de cómo hay que hacer las cosas. Miro el datasheet del display 5161AS y veo que el voltaje de operación es de 1,7 a 2,0 V, siendo el voltaje típico de 1,8 V. Además, me dice que la corriente de operación recomendada es de 12 mA. Entonces tomo 1,8 V y 12 mA.

    Si pongo en serie uno de los segmentos con una resistencia para calcular el valor de la resistencia, tengo que el voltaje total es
    Vt = Vr + Vd
    (es decir, la suma del voltaje de la resisencia + voltaje del diodos).

    De allí despejo Vr = Vt – Vd. Suponiendo que el voltaje total que me ofrece un pin del Arduino es de 5V, y el voltaje del diodo es 1,8V, calculamos
    Vr = Vt – Vd = 5 – 1,8 = 3,2V.
    Es decir que la caída de voltaje que tiene que provocar la resistencia es de 3,2 voltios.

    Sabiendo que
    R = Vr / I
    (donde la intensidad es la intensidad del circuito, la recomendada para el diodo: 12 mA=0,012A), de allí calculo:
    R = 3,2 / 0.012 = 267 omhs
    que es más o menos la resistencia que Ud. recomienda (330 ohms, mejor que sea algo superior por seguridad).

    Pero donde viene mi duda es: Ud. pone una UNICA resistencia compartida entre todos los leds del display. Si encendemos todos al mismo tiempo la intensidad de corriente que circula por el circuito será 7 veces mayor I = 12mA * 7 = 84 mA, entonces el nuevo cálculo de la resistencia sería
    R = Vr / I = 3,2 / 0,084 = 38 ohms.
    Es decir, pareciera que no es lo mismo compartir la misma resistencia para todos los leds, sino tendría que poner una resistencia individual para cada led.

    Perdón por mi ignorancia. Qué es lo que tengo mal en mi razonamiento? Quiero entender para aprender y no meter la pata.

    Muchas gracias anticipadamente por resolverme mi duda.

    John David Molina

    • Hola John,

      EN primer lugar he comprobado que hay modelos del 5161AS que efectivamente van a 1,8V pero el que estoy usando yo era de 5V y corresponde a varios led similares a los que utilizamos como bombillitas. No soy muy amigo de calcular demasiado en fino las corrientes porque probablemente asustariamos a los que se acercan de nuevo a la electronica, y por eso el razonamiento es mas o menos al reves

      Una unica resitencia limita efectivamente la corriente para todos de la misma manera que lo haria una resistencia por cada led, aunque efectivamente hay modificacion en la caida de tension general, pero no en la individual de cada LED ya que cada uno de ellos ve una resuistencia del valor total y normalmente los diodos reales tienen bastante tolerancia a pequeños excesos o caidas de tension.

      En realidad el problema seria que la corriente de paso por la rsistencia se multiplica efectivamente por tantos LEDs que se enciendan simultaneamente y pudiera ocurrir que se quemase si no lo calculamos correctamente.

  • Parece que no ha salido el titulo en mi anterior mensaje.
    Es el ejercicio que “has mandado” con el registro de desplazamiento.
    A ver si poco a poco le vamos cogiendo el “tranquillo”

    • Marote

    /* Valores de los segmentos que se deben encender en decimal, conversión de la matriz
    { 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,0,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

    Complementarios y menos peso a la derecha (Tengo un display de ánodo común)

    11000000 – 0 192
    11111001 – 1 249
    10100100 – 2 164
    10110000 – 3 176
    10011001 – 4 153
    10010010 – 5 146
    10000010 – 6 130
    11111000 – 7 248
    10000000 – 8 128
    10011000 – 9 152
    */

    int Digit[] {192,249,164,176,153,146,130,248,128,152} ;
    int latchPin = 8 ; //Pin conectado a ST_CP of 74HC595 (Verde)
    int clockPin = 12; //Pin conectado a SH_CP of 74HC595 (Amarillo)
    int dataPin = 11; //Pin connected to DS of 74HC595 (Azul)
    int valor = 0 ;

    void setup()
    { pinMode(latchPin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(dataPin, OUTPUT);
    }

    void loop()
    {
    for ( int k=0 ; k<10 ; k++) // Llama a Display para k de 0 a 9, los digitos
    { Display(k);
    delay(1000);
    }
    }

    void Display(int N)
    {
    digitalWrite(latchPin, LOW) ; // Latch a LOW para que no varíe la salida
    shiftOut(dataPin, clockPin, MSBFIRST, Digit[N]); // Aqui va Num
    digitalWrite(latchPin, HIGH) ; // Latch a HIGH fija valores en la salida
    delay(500);
    }

    • Santiago

    Buenas noches
    Lo primero de todo, muchas gracias por estos tutoriales, estoy iniciandome en el mundo de arduino y estan siendo de gran utilidad. Me gustaria aprovechar a preguntar una duda: en los displays de catodo comun, la resistencia se coloca en la salida comun del display a la toma de tierra. En este caso, no entiendo el motivo por el que la resistencia reduce el voltaje entrante en los leds. Al incluir una resistencia mayor, el brillo de los segmentos disminuye pero, al estar la resistencia despues de los leds, no acabo de comprender porque tiene efecto sobre estos. Dentro de mis conocimientos limitados, esperaria que el voltaje de entrada en los leds fuera el voltaje inicial, no influyendo las resistencias en la parte del catodo comun en el voltaje de entrada de estos. ¿Que se me escapa? Muchas gracias de antemano y felicidades por este gran trabajo

    • Hola Santiago, una pregunta interesante que no se me había ocurrido que pudiera plantearse a los que os iniciáis y que parece muy lógica.

      Vale, imagínate una cañería de agua en lugar de electrónica. Una resistencia sería equivalente a un tubo más estrecho que limitase el flujo de agua a su través y por tanto de todo el circuito. No importaría gran cosa que lo pusieras al principio o al final del circuito de agua porque al final en una cadena es el eslabón más débil el que determina la resistencia de la cadena y aquí igual.

      Por eso en un circuito eléctrico para que fluya la corriente se requiere una vía de circulación cuya limitación (Resistencia) viene dado por la resistencia conjunta de todo el circuito y no importa si la pones al principio o al final, sino su valor conjunto.

      Puedes poner la resistencia al principio pero como son de cátodo común necesitarías 4 en lugar de una y por pura vagancia la puse al final. Esto también nos lleva a que la intensidad que circula por la resistencia única es 4 veces superior y por tanto debes asegurarte de que puede soportarlo, pero como aquí hablamos de un máximo de 100 mA, lo he obviado)

    • Hola Santiago. Curiosamente, el sentido real de circulación de la corriente continua es de negativo a positivo, lo que por convenio se estableció desde un principio de positivo a negativo.

    • Fernanda Navarro

    Hola. Primeramente, agradezco los tutoriales. Voy comenzando con Arduino y me han parecido sumamente útiles.

    Sólo para comentar que hay un pequeño error.

    En el array, para efectuar el número “4” está apagado el segmento “b” por lo cual sale incompleto.
    Lo correcto sería así :

    { 0,1,1,0,0,1,1,0 }, // 4

    Saludos.

    • Muchas gracias por corregirme Fernanda, son los duendes que nos hacen malas pasadas, menos mal que vosotros me echais una mano.
      Suerte con tu aprendizaje

  • Primero que todo, muchas gracias por el tutorial. Me sirvió bastante. Quería saber si existe algún tutorial (o si podrían ayudarme directamente) para usar los mismos arrays con el display, pero que estos sean accionados por medio de un botón. Es decir, que al conectarlo y presionarlo, el display marque 1, 2, 3, …. y asi sucesivamente por cada vez que lo presione.

    • Hola Victor,
      El ejemplo que nos propones, resulta bastante sencillo y estaremos encantados de echarte una mano y dirigirte un poquito si es lo que necesitas.
      Basta con que crees una variable que se va incarementando cada vez que pulsas el boton (Echa una ojeada al tutorial sobre condicionales y botones) y despues ya sabes como mostrar ese numero.
      Si vas escribiendo algun programa y quieres que te lo revisemos abre un hilo en los foros para que te podamos ayudar varios
      Un saludo

      • Muchas Gracias. ¿El hilo debo abrirlo en “Proyectos” o en alguna otra categoría?

  • Buenos días:
    La prueba de que aprendo mucho con tus tutoriales es que encuentro fallo y los corrijo.
    En la línea
    for (int I = 2; i<11; i++)
    la variable I debe ir en minusculas i
    ….. Creo yo¡¡¡
    Felicidades por la claridad y gracias por la libre disposición y por tu esfurezo

    • Muchas gracias Jose Manuel

      Ciertamente tienes razon y te agradezco sinceramente los comentarios y errores que encuentras porque nos sirven para mejorar y que no se tropiecen otros

    • Alberto Palomero

    Iep,

    Veo que en el codigo(array) ya lo tienes bien puesto, pero en la tabla de combinaciones de LEDS el numero uno lo tienes con todos los leds apagados, te falta poner segmentos b,c=1,

    Saludos y gracios por estos tutos…me tienes enganchado!

    • Veo que los gremlins han vuelto a hacer de las suyas y efectivamente había un error. Muchas gracias por indicarmelo ALberto, ya está corregido.

Give a Reply

WordPress Anti-Spam by WP-SpamShield

¡Oferta!

Promoción especial de abril.

Tu robot educativo por

49,95

Ir al producto