ARD15 – Arduino Mega

Facebooktwittergoogle_pluslinkedinmailFacebooktwittergoogle_pluslinkedinmail

En este artículo vamos a introducir a Arduino Mega 2560. Se trata de una versión de Arduino con otra microcontroladora, que permite disponer de muchos más pines, tanto digitales, digitales PWM, analógicos de entrada, y de comunicación serie (Tx – Rx). Eso supone más prestaciones en cuanto al número de actuadores y dispositivos que podemos emplear en nuestros montajes, dándonos opción a realizar montajes más complejos y completos, con funcionalidades que sería muy difíciles de implementar (en ocasiones, imposibles) en un Arduino UNO.

En la figura 15.1 ves una foto de Arduino Mega, donde puedes verse la cantidad de pines de que dispones.

Figura 15.1. La tarjeta Mega tiene una gran cantidad de pines.

Figura 15.1. La tarjeta Mega tiene una gran cantidad de pines.

Las características más relevantes de Arduino Mega 2560 son:

  • Microcontrolador: ATmega2560
  • Tensión de funcionamiento: 5V
  • Tensión de entrada (recomendada): 7-12V
  • Tensión de entrada (límite): 6-20V
  • Pines digitales de E/S: 54 (de los que 15 pueden ser programados como salida PWM)
  • Pines analógicos de entrada: 16
  • Corrienta máxima en los pines E/S: 20 mA
  • Corriente máxima para el pin de 3.3 V: 50 mA
  • Memoria Flash: 256 KB (de los que 8KB son usados por el bootloader)
  • SRAM: 8 KB
  • EEPROM: 4 KB
  • Velocidad de reloj: 16 MHz
  • Longitud: 101.52 mm
  • Anchura: 53.3 mm
  • Peso: 37 g

Cuando desempaquetes tu nueva tarjeta Arduino Mega, lo primero que tienes que hacer es “enseñarle” a tu ordenador y a tu IDE Arduino a reconocerla, para que todo te funcione como hasta ahora.

En cuanto al ordenador, la cosa es fácil. Simplemente la enchufas y Windows te la reconoce e instala los drivers adecuados en unos minutos, como ocurre con muchos dispositivos USB. Cuando Windows termine deberás comprobar que ha quedado bien instalada. Para ello, apoya el puntero sobre el icono Mi PC (con la tarjeta Arduino Mega conectada por USB, obviamente) y haz clic con el botón derecho. En el menú contextual elige Propiedades. Se te abrirá una ventana en la que, en el menú de la izquierda, deberás acceder a Administrador de dispositivos (dependiendo de tu configuración, Windows podría pedirte tu clave de usuario). En la ventana que se te abre, con la lista de dispositivos del sistema despliega Puertos (COM y LPT). Te aparecerá Arduino Mega 2560 (COM5). En mi caso, aparece como COM5. A ti te puede aparecer con otro número de puerto. En todo caso, anota el número. Si te aparece un pequeño tríángulo amarillo, el controlador no ha quedado correctamente instalado. Deberás instalarlo de nuevo. Puede que haya habido algún problema de reconocimiento de la tarjeta. Desconectarla del USB y volver a conectarla, dejando que Windows haga el trabajo de reinstalación, suele funcionar en casi todos los casos.

Ahora abre tu IDE Arduino. En el menú de la barra superior pulsa sobre la opción Herramientas. Se te despliega un menú en el que pulsaras sobre la opción Placa. Esto te abre la lista de placas Arduino que tu IDE puede reconocer. Marca la opción Arduino Mega or Mega 2560.

Después, de vuelta en el menú superior, abrimos de nuevo el menú Herramientas. Esta vez pulsamos sobre la opción Puerto. Saldrá una lista de puertos por los que Arduino se conecta. Si sólo te aparece uno, ese es el de tu placa Arduino Mega (como te comentaba, en mi caso es COM5). En todo caso, el puerto que estés usando para Arduino Mega debe tener un tick (marca de activación) a la izquierda del nombre del puerto. Si no lo tiene, haz clic sobre el nombre de dicho puerto.

Y ya está. En este momento, lo tienes todo configurado para funcionar con tu Arduino Mega 2560.

A partir de aquí, vamos a realizar un montaje que empleará casi todos los pins digitales. Como no vamos a emplear la consola Serial, no tendremos que preocuparnos de cuales son Tx o Rx. Esta vez, todos los pines los emplearemos para comunicar la placa con el circuito.

EL MONTAJE

Empecemos describiendo lo que queremos hacer.

En artículos anteriores hemos experimentado con el display LED de siete segmentos, y también con un teclado matricial.

En este artículo, nuestro montaje tendrá cuatro displays LED de siete segmentos, un teclado matricial, y dos LEDs convencionales, uno verde y otro rojo.

El sistema esperará a que introduzcamos la clave prefijada, como un PIN, es decir, una secuencia de cuatro dígitos.

Cada dígito numérico que pulsemos, aparecerá en un de los cuatro displays, de tal modo que, cuando hayamos tecleado el PIN completo, este aparecerá entero. Si pulsamos el botón que destinemos a borrar el último dígito tecleado, este desaparecerá del pin.

Cuando pulsemos el botón de validación, si están los cuatro dígitos introducidos y el PIN en correcto, se encenderá el LED verde. Si el PIN es incorrecto, o faltan dígitos, se encenderá el LED rojo.

Si borramos todos los dígitos, o aún no hemos introducido nada, los cuatro displays mostrarán encendido, por defecto, el punto de la parte inferior derecha, indicando que debemos introducir dígitos.

Parece una funcionalidad muy simple. En otro entorno de desarrollo, como PHP o Python, la introducción y verificación de un PIN, usando el teclado y monitor de nuestro PC podría ser cosa de media docena de líneas, y diez minutos de programación.

En entorno Arduino, donde debemos programar cada detalle operativo (además, desde luego, de construir el circuito) la cosa es algo más compleja, pero, desde luego, mucho más interesante.

En la figura 15.2, vemos el esquema teórico completo del circuito. Como ves, cada display tiene todas las conexiones necesarias a distintos pines de la tarjeta Arduino. Es importante que tengamos una lista de que pines van a que segmentos de que displays, ya que, con tantas conexiones, a la hora de escribir el sketch es muy fácil cometer errores que serían de muy difícil localización.

Figura 15.2. Esquema teórico de cuatro displays conectados a Mega.

Figura 15.2. Esquema teórico de cuatro displays conectados a Mega.

Observa, en el esquema, que también hemos incluido el teclado (al lado del módulo Arduino) y los LEDS de verificación (el rojo y el verde), así como las resistencias necesarias en los displays. El esquema, por sus dimensiones, deberás mirarlo en apaisado.

ATENCIÓN. Aunque en el esquema no puede apreciarse con claridad, las resistencias que unen el pin activo de cada LED a masa, para evitar que en ningún momento los pines queden “al aire” (ya hemos hablado de esto en otro artículo anterior), son de 10kΩ. La resistencia que une los pines de masa a la masa de la alimentación es de 1kΩ.

Tabla de conexiones de los displays con los pines de Arduino Mega.

Tabla de conexiones de los displays con los pines de Arduino Mega.

Tabla de conexiones del teclado con los pines de Arduino Mega.

Tabla de conexiones del teclado con los pines de Arduino Mega.

Ahora viene la parte de ver el montaje físico. Se trata de un montaje complejo, en el sentido de que está muy recargado de cableado, así que no vamos a verlo en una sola imagen final, ya que seríamos incapaces de “verlo”, realmente. Vamos a ir viendo cada etapa del montaje, en imágenes sucesivas, hasta que lo tengamos completo. En las figuras de 15.3 a 15.8 se ven las distintas fases del montaje.

Figura 15.3. Primera fase del montaje. Conexionado básico de la protoboard a Mega, y cablecillos negros que unen las conexiones donde irán los pines comunes (de masa) de los displays.

Figura 15.3. Primera fase del montaje. Conexionado básico de la protoboard a Mega, y cablecillos negros que unen las conexiones donde irán los pines comunes (de masa) de los displays.

En la primera fase del montaje vemos que hemos efectuado casi la totalidad de las alimentaciones y las masas:

  • Hemos conectado El punto Vcc 5V y la masa (GND) de Arduino Mega al bus de alimentación de la protoboard.
  • Hemos conectado una resistencia de 1 KΩ que conectará el cátodo común de el display de siete segmentos situado más a la izquierda, a la masa. Esta resistencia será común a los cuatro displays. Por esto, aparecen unos cables negros de conexión que unen los puntos donde irán los cátodos comunes de los cuatro displays. Los displays se montarán encima de estos cables, de forma que los pines correspondientes a los cátodos coincidan con dichos cables.
  • Hemos llevado la masa, desde el bus de masa superior al bus de masa inferior, porque necesitaremos masa también en esa parte de la protoboard.
Figura 15.4. Detalle de la segunda fase del montaje. Se han insertado los cuatro displays (los cablecillos negros de las masas quedan por debajo), y se han colocado las resistencias inherentes.

Figura 15.4. Detalle de la segunda fase del montaje. Se han insertado los cuatro displays (los cablecillos negros de las masas quedan por debajo), y se han colocado las resistencias inherentes.

En la segunda fase vemos que hemos puesto los displays en la parte izquierda de la protoboard. Los tres cablecillos que unen los cátodos comunes ya no son visibles porque están, físicamente, debajo de los displays. Observa que todos los segmentos de cada display (los siete que se usan para visualizar el número y el octavo, que se usa para el punto, están unidos a masa a través de resistencias de 10 kΩ. Esta es una fase que lleva bastante tiempo de elaboración (una media hora), y hay que poner especial atención en conectar las resistencias en los puntos correctos. Presta especial atención al hecho de que todos los cátodos comunes de los displays no llevan resistencias, excepto el pin central superior del display más a la izquierda que, como vimos en la fase anterior, lleva la resistencia de 1 kΩ que sirve a los cuatro displays.

Figura 15.5. En la tercera fase se han cableado las conexiones del primer display a la tarjeta Mega.

Figura 15.5. En la tercera fase se han cableado las conexiones del primer display a la tarjeta Mega.

En la tercera fase vemos el primer display conectado a Arduino. Observa que cada pin de un segmento luminoso va conectado al pin Arduino que se indica en la tabla de conexiones que hay dos páginas más arriba. Para saber a que segmento corresponde cada pin, échale un vistazo a la figura 14.2 del artículo ARD14. Te puede parecer incómodo, ahora, que hayamos empleado el mismo color en los ocho cables del display, pero te aconsejo que lo hagas así en tu montaje, para poder usar distintos colores de cablecillos en cada display. En todo caso, es una cuestión de criterio.

Figura 15.6. En la cuarta fase se han cableado las conexiones del segundo display a la tarjeta Mega.

Figura 15.6. En la cuarta fase se han cableado las conexiones del segundo display a la tarjeta Mega.

Cuarta fase: ya vemos el segundo display conectado. Hemos tenido en cuenta la nomenclatura de los segmentos del display, y los hemos conectado a los pines Arduino que figuran en la tabla de conexiones.

Figura 15.7. Ya están los cuatro displays conectados a la Mega. Como puedes ver, el "lío" de cables hace este montaje muy engorroso.

Figura 15.7. Ya están los cuatro displays conectados a la Mega. Como puedes ver, el “lío” de cables hace este montaje muy engorroso.

En la quinta fase del montaje vemos los cuatro displays conectados a los pines de Arduino que aparecen en la tabla de conexiones. Como ves, en este momento hay una “maraña” de cablecillos que hacen difícil seguir cada uno individualmente. Como ya te avisé, este es un montaje inherentemente engorroso. Y el montaje físico es aún más delicado, ya que tienes que poner especial atención a que ningún cablecillo se salga de su pin, ni en la placa Arduino, ni en la protoboard. Además, tendrás que disponer los cablecillos de modo que tapen los displays lo menos posible, para poder visualizarlos. Es una tarea laboriosa, pero el resultado final merecerá la pena, sobre todo a efectos didácticos. Vamos a aprender mucho en este capítulo.

Y, de momento, vamos a interrumpir aquí el montaje. Aún no vamos a conectar el teclado ni los dos LEDs de señalización.

PROBANDO LOS DISPLAY DE SIETE SEGMENTOS

Vamos a escribir un primer sketch que nos va a servir para probar el funcionamiento de los cuatro displays de siete segmentos. Este nos servirá para asegurarnos de que todos los pines están correctamente conectados, así como para sentar alguna bases de la programación de Arduino.

Esta vez, vamos a hacer las cosas al revés. Vamos a detallar cada parte del sketch, y luego mostraremos el listado completo. Para variar un poco.

En primer lugar, definimos una matriz bidimensional, de tipo byte, que contendrá todos los pines de Arduino a los que van conectados los distintos segmentos de los cuatro displays. La matriz tendrá una fila por cada display y, dentro de estas, un elemento por cada pin, así:

byte displays_pines[4][8] = {
    {7, 6, 5, 4, 3, 2, 1, 0},
    {38, 39, 40, 41, 42, 43, 44, 45},
    {46, 47, 48, 49, 50, 51, 52, 53},
    {37, 36, 35, 34, 33, 32, 31, 30}
};

Observa que, al definirla, hay dos índices. El primero nos dice que habrá cuatro filas (por cada uno de los cuatro displays) y el segundo que habrá ocho columnas (ocho elementos en cada fila), que se refieren a los pines que corresponden a los ocho LEDs de cada display (cada uno de los siete segmentos, y el punto).

Como sabes, los índices de la matriz empiezan a numerarse desde 0, no desde 1, por lo que las cuatro filas quedan identificadas como del 0 al 3 y las ocho columnas como del 0 al 7. Ten esto presente según vayamos detallando la operativa, y en sucesivos sketches.

A continuación vamos a definir una matriz que contendrá ocho valores, para asignar a los ocho segmentos del display con el que estemos trabajando en cada momento. La matriz va a ser de tipo byte y los valores que almacenará serán 0 o 1 que, como ya sabemos, equivalen a las constantes de Arduino LOW y HIGH. Así, al asignar estos valores a los pines de un display, encenderemos o apargaremos los segmentos deseados. En principio, vamos a inicializar la matriz con los ocho valores a 0, así:

byte valor_segmentos[8] = {0, 0, 0, 0, 0, 0, 0, 0};

Y ahora definimos otra matriz. Esta será de tipo char y contendrá los distintos caracteres que podemos querer visualizar en cada uno de los displays. Tendrá once elementos, que contendrán los caracteres del 0 al 9 y el punto, así:

char caracteres[11] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'};

También necesitaremos unas variables auxiliares, para desplazarnos por las matrices, que actúen como índices de las mismas, así:

byte indice_caracteres = 0; // Índice de la matriz de caracteres
byte indice_displays = 0; // Índice de filas de la matriz de displays_pines
byte indice_segmentos = 0; // Ïndice de columnas de la matriz displays_pines,
// y también índice de la matriz valor_segmentos

De momento ya tenemos definidas las variables que vamos a usar. Ahora vamos a definir una función que se empleará para que podamos visualizar un carácter de la matriz de caracteres en un display determinado. Recuerda que una función es un fragmento de código que cumplirá una misión concreta, que se carga en memoria, pero que no se ejecutará hasta que sea invocada desde otra parte del sketch.

void mostrar(char caracter, byte led_display){
    switch(caracter){
        case '0':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 1;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 0;
            valor_segmentos[7] = 0;
            break;
        case '1':
            valor_segmentos[0] = 0;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 0;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 0;
            valor_segmentos[6] = 0;
            valor_segmentos[7] = 0;
            break;
        case '2':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 0;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 1;
            valor_segmentos[5] = 0;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '3':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 0;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '4':
            valor_segmentos[0] = 0;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 0;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '5':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 0;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '6':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 0;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 1;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '7':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 0;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 0;
            valor_segmentos[6] = 0;
            valor_segmentos[7] = 0;
            break;
        case '8':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 1;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '9':
            valor_segmentos[0] = 1;
            valor_segmentos[1] = 1;
            valor_segmentos[2] = 1;
            valor_segmentos[3] = 1;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 1;
            valor_segmentos[6] = 1;
            valor_segmentos[7] = 0;
            break;
        case '.':
            valor_segmentos[0] = 0;
            valor_segmentos[1] = 0;
            valor_segmentos[2] = 0;
            valor_segmentos[3] = 0;
            valor_segmentos[4] = 0;
            valor_segmentos[5] = 0;
            valor_segmentos[6] = 0;
            valor_segmentos[7] = 1;
            break;
    }
    for (indice_segmentos = 0; indice_segmentos < 8; indice_segmentos ++){
digitalWrite(displays_pines[led_display] indice_segmentos], valor_segmentos[indice_segmentos]);
    }
}

Esta función recibirá, como argumentos, el carácter que queramos visualizar y el display en el que queramos visualizarlo.

Lo primero que hace la función es definir. en la matriz de valores de segmentos, cuales estarán activos (valor 1) o inactivos (valor 0), según el carácter que le hayamos pasado. Después, recorre esa matriz en un bucle, que empieza en 0 y acaba cuando el índice sea menor que 8, es decir, que recorre la matriz completa, desde índice 0 hasta índice 7.

Dentro del bucle usa digitalWrite() para escribir el valor deseado (0 o 1) en el segmento que corresponde, del display elegido. Para ello, determina la fila de pines de displays mediante el segundo argumento recibido y el pin concreto mediante el mismo índice que usamos para recorrer la matriz de valores.

Dentro de la sección setup encontramos lo siguiente:

void setup() {
    for (indice_displays = 0; indice_displays < 4; indice_displays ++){
        for (indice_segmentos = 0; indice_segmentos < 8; indice_segmentos ++){
            pinMode(displays_pines[indice_displays][indice_segmentos], OUTPUT);
            digitalWrite(displays_pines[indice_displays][indice_segmentos], LOW);
        }
    }
}

Como ves, lo que hacemos es recorrer, en un bucle, las cuatro filas de la matriz que define los pines de los displays. Dentro de este bucle (dentro de cada fila) vamos seleccionando los pines que corresponden a cada uno de los segmentos, en otro bucle.

En este bucle interior, definimos cada pin como de salida, y le asignamos el valor LOW. De este modo, al inicio, todos los segmentos de todos los display se mostrarán apagados.

Ahora vamos a la sección loop que, como sabemos, se va a estar repitiendo mientras la placa Arduino esté recibiendo alimentación.

void loop() {
    if (indice_caracteres == 11) indice_caracteres = 0;

        for (indice_displays = 0; indice_displays < 4; indice_displays ++){
            mostrar(caracteres[indice_caracteres], indice_displays);
        }
        indice_caracteres ++;
        delay (1000);
}

Lo primero que vamos a hacer es comprobar si la variable que usamos como índice de caracteres ha alcanzado el valor 11. Como la matriz de caracteres tiene 11 elementos, esta variable deberá recorrerlos de 0 a 10. Si ha alcanzado, en algún momento, el valor 11, se pondrá a 0. Inicialmente vale 0 pero, como vemos unas líneas más adelante, en cada ejecución del loop se incrementa en una unidad.

Una vez que ya tenemos un valor para el índice de la matriz de caracteres, entramos en un bucle que va a recorrer cada uno de los cuatro displays (del 0 al 3), lo que, según el planteamiento que hemos hecho, se va a referir a cada una de las filas de la matriz bidimensional donde hemos definido los pines de cada display.

Dentro de ese bucle, invocamos a la función que muestra, en el display en curso, el carácter correspondiente de la matriz de caracteres. Como se recorren los cuatro displays, ese carácter será mostrado en cada uno de ellos. Después del bucle, se incrementa el índice de la matriz de caracteres, para que se muestre el siguiente carácter en la siguiente iteración de loop. Se incluye una demora de un segundo y se termina el proceso.

Por lo tanto, lo que hace este sketch es que muestra cada uno de los caracteres (del 0 al 9 y el punto) en todos los displays. Si ya has completado el montaje hasta donde hemos descrito, compruébalo ahora. Si alguno de los displays no muestra alguno de los caracteres correctamente, revisa todas las conexiones. Como son muchas, es muy fácil cometer un error. El listado completo de este sketch (que puedes copiar y pegar en tu IDE arduino) es:

AÑADIENDO EL TECLADO

Bien. Ya sabemos que los displays están correctamente cableados y funcionan sin problemas. En la figura 15.8 vemos el montaje final completo, con el teclado conectado según la tabla de conexiones que tenemos, y los dos LEDs indicadores, rojo y verde, para comprobar si la clave introducida por teclado se corresponde con la que establezcamos como correcta en el sketch.

Figura 15.8. El montaje ya está completo, con el teclado y los LED "testigo" incluidos.

Figura 15.8. El montaje ya está completo, con el teclado y los LED “testigo” incluidos.

Para confirmar los pines del teclado que corresponden a las filas y las columnas, revisa la figura 13.2 del artículo ARD13.

EL SKETCH

Además del código que ya tenemos (aunque tendremos que modificar alguna cosa), debemos incluir el código para el teclado y los LEDs indicadores.

Como ves, el listado parece bastante largo, pero no hay en él nada que no conozcamos ya. Lo único que pretendemos, al reproducirlo, es que lo sigas para ver como opera, y cómo hemos tenido en cuenta todas las variables. Cárgalo en tu Arduino Mega y verás como funciona.

SIMPLIFICANDO

El montaje que hemos hecho funciona perfectamente, pero es un engorro, tanto en la parte física (con todos los cables de los cuatro displays) como en el sketch, con toda la programación de los segmentos. Es hora de simplificarlo todo, ahorrándonos trabajo, y mejorando el resultado final. Para ello vamos a recrear este montaje, empleando, en lugar de los cuatro displays, la pantalla de cristal líquido LDC 1602 que aprendimos a manejar en el artículo ARD12.

Lo que haremos es que en el LCD aparezca un mensaje fijo pidiendo que teclees tu PIN. Según vayas pulsando los dígitos del teclado (hasta el máximo de cuatro números) estos irán apareciendo en las correspondientes posiciones de la línea inferior del display. Una vez tecleados los cuatro dígitos, pulsaremos la tecla “A” para validar la clave, y se encenderá el LED rojo o el verde, según la clave sea incorrecta, o sea la adecuada. El resto de la operativa será la misma. Si pulsamos la tecla “*” se borrará el último dígito y si pulsamos la tecla “D” se limpiará todo lo que hayamos tecleado.

EL MONTAJE

El esquema es ahora relativamente sencillo, al menos comparado con el anterior. Mira la figura 15.9.

Figura 15.9. Esquema del validador de PIN con LCD 1602A.

Figura 15.9. Esquema del validador de PIN con LCD 1602A.

Como puedes ver, es mucho más simple que el anterior. Además, en el LCD hemos suprimido el potenciómetro de contraste, ya que conectando el terminal 3 (V0) directamente a masa obtenemos el máximo contraste y, por tanto, la mejor visualización.

Aunque, por seguir la línea de este capítulo, hemos empleado Arduino Mega, podríamos haber hecho este monaje con la placa Arduino UNO, ya que tenemos pines de sobra.

El conexionado del teclado no ofrece ninguna duda, ni tampoco los de los LEDS verde y rojo que emplearemos para indicar si la clave tecleada es correcta o no.

También puedes comparar este montaje con el del articulo ARD12, en lo que al conexionado del LCD se refiere. Verás que esa parte también la hemos simplificado un poco. En la figura 15.10 ves el montaje físico.

Figura 15.10. El montaje físico con LCD.

Figura 15.10. El montaje físico con LCD.

EL SKETCH

Veamos el listado completo. Como puedes comprobar, sólo incluye técnicas que ya conocemos. Presta especial atención a los comentarios, que pueden aclararte algunos aspectos concretos de la operativa.

 

 

     

Un comentario:

  1. Pingback: ARD16 – Más sobre LED’s » eldesvandejose.com

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *