icono

TECLADO NUMÉRICO (keypad).

Experiencias con Arduino.


Idioma
Spanish English French German Italian Portuguese

Una experiencia con un teclado numérico.

Desde aquí, una vez más diré que el primer paso para aprender cualquier disciplina, se basa en dos partes fundamentales, la teoría y la práctica. Es hora de comprobar que todo lo que se ha hecho hasta este momento está bien y pasamos a familiarizarnos con el interfaz de desarrollo, una forma es abrir alguno de los ejemplos que incorpora Arduino o de los muchos que podemos descargar en Arduino.es en español y también en Wiring.org. Si todavía no lo ha hecho, recomiendo que abra el ejemplo "led_blink" y trate de comprender lo poco que se necesita para empezar.

Para seguir este tutor, se necesitan un mínimo de conocimientos de electrónica y algo de programación, que por otra parte, se da por echo que se tienen. Con la plataforma Arduino, todo lo que usted debe hacer es, escribir el código que será cargado en la tarjeta de Arduino.

Actualmente la manera más habitual de comunicación entre dispositivos electrónicos es la comunicación serial o vía USB y Arduino no es una excepción. A través de este tipo de comunicación podremos enviar/recibir datos desde nuestro Arduino a otros dispositivos, microcontroladores o a un computador corriendo alguna plataforma de desarrollo (Processing, PD, Flash, Director, VVVV, etc.).

Como se ha dicho, las tarjetas que se usan en la mayoría de los casos disponen de un acceso serial o USB para tal fin, estos conectores requieren de un sistema exterior para cargar el programa (bootloader) aun así, es evidente que mediante un teclado, se puede introducir ordenes sencillas.

Teclado de 12 contactos

Es aquí donde se encuentra a faltar un teclado numérico que permita al usuario entrar ciertas ordenes mínimas suficiente para un buen número de casos.

Se pretende describir el modo de aplicar un teclado numérico como entrada de datos a una aplicación desarrollada para un sistema basado en Arduino. Este sería un posible teclado numérico a usar.

Se trata de un pequeño teclado de 12 contactos o pulsadores, sin embargo el usuario con un poco de ingenio, puede adaptar todo lo que aquí se describe con unos ligeros cambios al teclado que le interese, siempre que esté dentro de ciertos parámetros, otra cosa es un teclado PS2, eso se puede ver en otros tutores.

Es más, en este tutorial, voy a desarrollar en torno a un teclado de tan sólo seis pulsadores o llaves, dispuestos en dos filas y tres columnas. Porqué motivo, simplemente porque es el que tuve que desarrollar para una aplicación concreta. Su esquemático de conexionado es este.

Esquemático de 6 contactos Esquemático de 6 contactos

En la figura aparecen 6 contactos, es evidente que, se puede aprovechar el teclado de un artilugio viejo que se dispone o del desguace de un portero telefónico, no se debe despreciar ningún tipo, lo que interesa son los contactos (4X3, 4X4). El lector debe adaptar parte del código del programa, según el modelo que disponga, con lo que su trabajo se reduce a unos pocos cambios.

El código.

En primer lugar, es muy importante documentar nuestro trabajo, parecería razonable pensar que "al menos en los inicios hasta que tengamos soltura con el lenguaje" si bien esto es cierto, no lo es menos el tratar de documentar todo nuestro trabajo (es algo que aprendí desde muy pronto y no me arrepiento), antes o después nos daremos cuenta, al tener que revisar una rutina que se escapa al motivo por el que la pusimos la primera vez. Esto redundará en que podremos reutilizar ciertas subrutinas en otros programas.

El programa que sigue, necesita el archivo fuente Keypad que es software libre (debe respetar la autoría), lo puede encontrar en la librería: matrixKeypad.zip. Según me aconsejaba el autor del artículo SparkFun en "Frikadas con Arduino", dice: "Para hacer funcionar este keypad con Arduino hay que realizar una serie de modificaciones en la librería (ver descarga al final del post), ya que este modelo de keypad usa un pineado no estándar, además aprovechando las características del microcontrolador Atmel168 usaremos los (pull-ups) internos para ahorrarnos un par de resistencias en las entradas. Ver el enlace sobre DigitalPins en arduino mas abajo para leer mas sobre los pull-ups (en español, Resistencias de polarización).

Editar el archivo "keypad.cpp" y modificar los siguientes puntos:

#define COL0 11 // #05
#define COL1 12 // #01
#define COL2 13 // #03
#define COL3 5 // not used as this is a 3 Col x 4 Row keypad
#define ROW0 7 // #02
#define ROW1 8 // #07
#define ROW2 9 // #06
#define ROW3 10 // #04

Y más abajo en:

 Seccion original "solo funcion init"):
 void keypad::init ()
 {
 for (int c=0; c<num_cols; c++)
 {
 pinMode(col[c],OUTPUT);       // Set column pins as outputs for writing
 digitalWrite(col[c],HIGH);        // Make all columns inactive to start with.
 }
 col_select = 0;                   // Start with the first column.
 }

 New: "añadir el texto marcado en rojo"
 void keypad::init ()
 {
 for (int c=0; c<num_cols; c++)
 {
 pinMode(col[c],OUTPUT);           // Set column pins as outputs for writing
 digitalWrite(col[c],HIGH);        // Make all columns inactive to start with.
 }
  
 for (int r=0; r<num_rows; r++)
 {
 digitalWrite(row[r],HIGH);        // Make all rows turn on pullup resistor.
 }
 col_select = 0;                   // Start with the first column.
 }

El código que vamos a utilizar, para este artículo, se puede descargar desde la misma aplicación Arduino, el original, se encuentra en el apartado "Codigo comentado", en la capeta Keypad, yo lo he adaptado a mis necesidades. También, se puede copiar de aquí, y pegar en su editor favorito, guardar con la extensión .pde en este caso debe localizar la librería "Keypad" en la web de Arduino, como se comenta más arriba.

Keypadtest

El siguiente es un código de prueba del LED para teclado:
Código: Seleccionar todo
/* Keypadtest.pde
*
* Demuestra el empleo más simple de la biblioteca de teclado.
*
* El primer paso debe conectar su teclado al Arduino, utilizar los
* números de pines catalogados debajo en rowPins [] y colPins [].
* Si usted quiere usar diferente pines entonces, usted debe
* cambiar los números de abajo para adaptar su sistema.
*
*
* Nota: Asegúrese de usar resistencias de polarización en cada
* uno de los rowPins (las filas).
*
* Ha sido modificado y probado con éxito el: 18/06/09 16:43:00
* ver. 0023
*/
#include <Keypad.h>

// Conecte keypad ROW1 y ROW0 a los pines de Arduino.
byte rowPins[] = { 9, 8 }; // he modificado a 2 filas
// Conecte keypad COL2 COL1 y COL0 a los pines de Arduino.
byte colPins[] = { 12, 11, 10 }; // he modificado a 3 columnas
// Crear el teclado (keypad).
Keypad kpd = Keypad(rowPins, colPins, sizeof(rowPins), sizeof(colPins));

#define ledpin 13

void setup()
{
digitalWrite(ledpin, HIGH);
Serial.begin(9600);
}

void loop()
{
char key = kpd.getKey();
if(key) // same as if(key != NO_KEY)
{
switch (key)
{
case '*':
digitalWrite(ledpin, LOW);
break;
case '#':
digitalWrite(ledpin, HIGH);
break;
default:
Serial.println(key);
}
}
}

Hay un detalle que puede pasar desapercibido. Note que, en este código, no se utiliza la habitual rutina con retardo que venimos comentando, para evitar los efectos del rebote, producido por los contactos de los pulsadores, esto es debido a que utilizamos la librería Keypad.h Si revisa el contenido de esta librería, puede ver que sí se tiene en cuenta este efecto.

Ahora, puede copiar y pegar el código anterior y guardarlo en un archivo con la extensión .pde. Básicamente, este código describe cómo utlizar la mencionada librería de una forma práctica.

  1. - Define los pines que corresponde a las filas y a las columnas.
  2. - Crea el "teclado" que exije dicha librería que se llama Keypad.
  3. - Define las salidas, en este caso sólo emplea un LED (el propio pin13, del Arduino.
  4. - Le sigue la configuración de las E/S ("el setup") y las comunicaciones con el PC.
  5. - Una simple pero efectiva rutina para identificar la tecla (pulsador) presionado.
  6. - Y la última línea, sirve para mostrar en el monitor serie la tecla presionada.

Cuando abra su sistema de desarrollo, vaya a File/Sketchbook/ busque el archivo que acaba de pegar, si no lo ven en el listado que se muestra, vaya a File/Sketchbook>Open... y trate de encontrarlo con el buscador que presenta. Una vez encontrado, debe fijarse en el listado del código y si el nombre keypad #include <Keypad.h> no aparece en color como se muestra, usted debe proceder del siguiente modo:

Una vez la haya pegado en su sitio, vuelva a File/Sketchbook> Open..., pulse dicha librería y se añadirá de forma correcta a su código. Ahora todo está dispuesto para seguir. Primero, verifique el código, para lo cual pulse el botón con la flecha Verify, si todo está bien, se mostrará una línea similar a esta: Binary sketch size: 3010 bytes (of a 14336 byte maximum) al pié de la aplicación. Esto significa que todo esta correcto y se puede enviar el código .h resultante a la tarjeta Arduino.

Todo bien

Si hubo errores en su código, se suele mostrar la línea donde reside el error destacado en una línea en color, una leyenda sobre la causa posible, como se muestra.

Error

Verifique minuciosamente de nuevo su código y modifique los posibles errores, trate de entender los mensajes que le da el error, son una pista a seguir.

Nota. Si usted lo que ve es algo parecido a esto:

Falta Arduino

Usted no tiene un error, es típico que se muestre esto, cuando no haya conectado al PC la tarjeta de Arduino. Conecte su Arduino y proceda a enviar de nuevo el código.

Ahora se mostrará este letrero:

Correcto

Si en su código utiliza el Serial.begin(9600); y Serial.println(n); mediante el monitor serie, puede comprobar la salida del resultado de presionar cada pulsador, como prueba de funcionamiento.

serialmonitor

Puede enviar datos al Arduino y ver la recepción de datos que le devuelve Arduino, verificando que el programa cumple lo especificado.

Efectivamente, cuando se presiona un pulsador, en el monitor serie, se muestra el número que corresponde a dicho pulsador, una vez comprobados los seis pulsadores podría dar por terminado el artículo del teclado, pero no es así. Hasta aquí que he hecho, nada nuevo, lo propio es que el teclado sirva para algún propósito y eso es lo que hace falta aquí para dar por terminado el tema del teclado, no os parece.

teclado6puls

Resultados.

En primer lugar, cuando se presiona una tecla o pulsador, debe producir un efecto, se trata de una orden y esto conlleva una reacción, una salida, actúa sobre un relé o enciende un LED, algo ocurre, ha de hacer algo.

Este código es muy sencillo y se puede ampliar con bastante sencillez, lo vamos a mejorar consiguiendo que haga algo más que indicar el pulsador que se ha presionado como hemos visto hasta ahora.

Mejorando el código.tecladoleds6

Tomaremos el listado del código anterior como punto de partida, para realizar un nuevo código que cubras nuestras especificaciones, con esto, como digo habremos aprovechado una buena parte del mismo y tiempo. Ahora, sólo tendremos que añadir las líneas que definen las diferencias. A la derecha el montaje esquematizado del circuito.

La definición de los pines que corresponden al teclado como son las filas, las columnas y el teclado (keypad), los dejamos como están.

A continuación se presenta el código con los cambios. Se ha dado una función de salida en la detección de tecla pulsada, enviando el flujo del programa a la subrutina especifica según la tecla presionada.

La rutina es realmente la misma para cada caso, lo único que cambia es el contenido de la subrutina de salida. Al entrar en la subrutina, se comprueba la situación de las salidas, según el estado de salida, se toma una decisión que lleva a la ejecución de una salida prevista. Es conveniente que el lector siga los pasos del programa para comprender mejor su desarrollo. Este es el listado del código a utilizar:

Keypadluces

El siguiente es el código de prueba, similar al anterior, cambia la subrutina:
Código: Seleccionar todo
/* Keypadluces.pde
*
* Demuestra el empleo más simple de la biblioteca de teclado.
*
* En el primer paso, debe conectar su teclado al Arduino la
* dutilización e los números de pines catalogados debajo en
* rowPins[] y colPins[]. Si usted quiere usar diferentes pines,
* entonces usted puede cambiar los números de abajo para
* emparejar su sistema.
*
*
* Ha sido escrita con éxito: 24/08/10 17:23:00
* Ha sido probada con éxito: 24/08/10 23:15 y ...
* El ledpin parpadea al pulsar cada tecla.
* Modificado el: 21/08/10
* Se ha añadido los LEDs, ledpin1, 2 y 3.
* ver. 0023
*/
#include <Keypad.h>

// Conecta keypad ROW0, ROW1 (filas) a los pines de Arduino.
byte rowPins[] = { 9, 8}; // he modificado a 2 filas.
// Conecta keypad COL0, COL1 y COL2 a los pines.
byte colPins[] = { 12, 11, 10 }; // he modificado a 3 columnas.

// Crea el teclado (keypad).
Keypad kpd = Keypad(rowPins, colPins, sizeof(rowPins), sizeof(colPins));

#define ledpin 13 // El LED de la misma placa Arduino

#define ledpin1 2 // pin del LED de salida
#define ledpin2 3 // pueden ser entradas
#define ledpin3 4 // a transistores para relés.
#define ledpin4 5 // pin del LED de salida
#define ledpin5 6 // pueden ser entradas
#define ledpin6 7 // a transistores para relés.

// Lo que sigue se añadió
int val; // variable para leer el pin status
int val2; // variable para leer el delayed status
int buttonState; // variable para guardar el estado del botón
int lightMode = 0; // Cuál es el modo de la luz
// hasta aqui

void setup() {
pinMode(ledpin, OUTPUT);
// digitalWrite(ledpin1, HIGH); // activa la RPA

digitalWrite(rowPins[8,9], INPUT);

digitalWrite(ledpin1, OUTPUT); // [1] ...
digitalWrite(ledpin2, OUTPUT);
digitalWrite(ledpin3, OUTPUT);
digitalWrite(ledpin4, OUTPUT);
digitalWrite(ledpin5, OUTPUT);
digitalWrite(ledpin6, OUTPUT);
Serial.begin(9600); // Establece comunicación Serie a 9600 bps,
// usado para depuración.

buttonState = digitalRead(rowPins[8,9]); //lee estado inicial del teclado
}

// Lazo principal - debería ser fácil de seguir
void loop() {

char key = kpd.getKey();
if(key) // lo mismo que if(key != NO_KEY)
val = digitalRead(rowPins[8,9]); // lee valor input y lo guarda en val
delay(10); // 10 milisegundos es un buen tiempo.
{
switch (key)
{
case '1':
digitalWrite(ledpin, LOW);
if (lightMode == 0) { // si están apagados
lightMode = 1; } // los enciende
break;
case '2':
digitalWrite(ledpin, HIGH);
if (lightMode == 1) { // si están todos encendidos
lightMode = 2; } // los pone a parpadear
break;
case '3':
digitalWrite(ledpin, LOW);
if (lightMode == 2) { // if its blinking
lightMode = 3; } // make it wave!
break;
case '4':
digitalWrite(ledpin, HIGH);
if (lightMode == 3) { // if its waving,
lightMode = 4; } // turn light off!
break;
case '5':
digitalWrite(ledpin, LOW);
if (lightMode == 4) { // if its waving,
lightMode = 5; } // turn light off!
break;
case '6':
digitalWrite(ledpin, HIGH);
if (lightMode == 5) { // if its waving,
lightMode = 0; } // turn light off!
break;
default:
Serial.println(key);
}
buttonState = val; // guarda el nuevo estado la variable
}

// Ahora hacer lo que lightMode indica
if (lightMode == 0) { // todo apagado
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
}
if (lightMode == 1) { // todo encendido
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
}

if (lightMode == 2) { // parpadeo
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
delay(100);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
delay(100);
}
if (lightMode == 3) { // "onda der."
digitalWrite(ledpin6, LOW);
digitalWrite(ledpin1, HIGH);
delay(50);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, HIGH);
delay(50);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, HIGH);
delay(50);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, HIGH);
delay(50);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, HIGH);
delay(50);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, HIGH);
delay(50);
}
if (lightMode == 4) { // "onda izq."
digitalWrite(ledpin6, LOW);
digitalWrite(ledpin5, HIGH);
delay(50);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin4, HIGH);
delay(50);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin3, HIGH);
delay(50);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin2, HIGH);
delay(50);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin1, HIGH);
delay(50);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin6, HIGH);
delay(50);
}
if (lightMode == 5) { // 1/2 + 1/2 parpadeo
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
delay(100);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
delay(100);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
delay(100);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
delay(100);
}
}

Copie y pegue el listado, en un nuevo archivo y guárdelo con el nombre por ejemplo, keypadluces.pde, inicie y cargue en su ID para compilarlo. Cuando termine, se supone que no hay problemas, ejecute el programa y compruebe los efectos que se han previsto en las subrutinas. Haga el montaje, compruebe cómo funciona realmente el programa, de esa forma podrá comprender mejor los cambios que vamos a realizar.

Mejora final el código.

Observando el código, se puede intuir que podemos prescindir de algunas líneas, sobre todo cuando comprobamos que para poder ver las diferentes salidas, es necesario realizar una secuencia que tampoco parece necesaria. Es decir, podemos hacer las mismas combinaciones de luces, sin la necesaria secuencia de las teclas (1, 2, 3, 4, 5, 6).

Para esto, vamos ha realizar unos cambios que influyen en este procedimiento ya que reduce las líneas del mismo, al mismo tiempo se consigue un funcionamiento más sencillo y mantiene las características iniciales.

 digitalWrite(ledpin, LOW);
 if (lightMode == 0) {          // si están  apagados  
  lightMode = 1; }              // los enciende   
  break;
  // lo modificamos del siguiente modo...

 digitalWrite(ledpin, LOW);

 lightMode = 1;          // los enciende   // ? no está la llave }        
  break;   
   

La corrección anterior, se debe realizar en cada una de las seis subrutinas, para que el programa funcione de modo correcto. Además de esto, se han hecho unas correcciones más que, darán un código más compacto y seguro.

La modificación en la configuración de los pines que estaban, en el código anterior, como: digitalWrite(ledpin1, OUTPUT); [1] ver arriba. Ahora, cambia a: pinMode(ledpin1, OUTPUT);, esto lleva a considerar seriamente a la hora de configurar un pin especifico a comportarse como entrada o salida. En este punto, recomiendo leer la descripción de pines digitales, para disipar cualquier duda.

A continuación se presenta el nuevo listado del código completo que se ha descrito.

El siguiente es el código definitivo del sistema descrito:
Código: Seleccionar todo
/* Keypadtest.pde
*
* Demuestra el empleo más simple de la biblioteca de teclado.
*
* En el primer paso, debe conectar su teclado al Arduino la utilización
* de los números de pines catalogados debajo en rowPins [] y
* colPins []. Si usted quiere usar diferentes pines, entonces usted
* puede cambiar los números de abajo para emparejar su sistema.
*
*
* Ha sido escrita con éxito: 24/08/10 17:23:00
* Ha sido probada con éxito: 24/08/10 23:15 y ...
* El ledpin parpadea al pulsar cada tecla.
* Modificado el: 21/08/10
* Se ha añadido los LEDs, ledpin1, 2 y 3.
*
*/
#include <Keypad.h>

// Conecta keypad ROW0, ROW1 (filas) a los pines de Arduino.
byte rowPins[] = { 9, 8}; // he modificado a 2 filas.
// Conecta keypad COL0, COL1 y COL2 a los pines.
byte colPins[] = { 12, 11, 10 }; // he modificado a 3 columnas.

// Crea el teclado (keypad).
Keypad kpd = Keypad(rowPins, colPins, sizeof(rowPins), sizeof(colPins));

#define ledpin 13 // El LED de la misma placa Arduino

#define ledpin1 2 // pin del LED de salida
#define ledpin2 3 // pueden ser entradas
#define ledpin3 4 // a transistores para relés.
#define ledpin4 5 // pin del LED de salida
#define ledpin5 6 // pueden ser entradas
#define ledpin6 7 // a transistores para relés.

// Lo que sigue se añadió
int val; // variable para leer el pin status
int val2; // variable para leer el delayed status
int buttonState; // variable para guardar el estado del botón
int lightMode = 0; // Cuál es el modo de la luz
// hasta aqui

// Declaración del estado de los pines

void setup() {
pinMode(ledpin, OUTPUT);
// digitalWrite(ledpin1, HIGH); // activa la resistencia pullup

digitalWrite(rowPins[8,9], INPUT);
pinMode(ledpin1, OUTPUT);
pinMode(ledpin2, OUTPUT);
pinMode(ledpin3, OUTPUT);
pinMode(ledpin4, OUTPUT);
pinMode(ledpin5, OUTPUT);
pinMode(ledpin6, OUTPUT);
Serial.begin(9600); //Establece com. Serie 9600bps, usado para depurar.
buttonState = digitalRead(rowPins[8,9]); // lee estado inicial del teclado
}

// Lazo principal - debería ser fácil de
void loop() {

char key = kpd.getKey();
if(key) // lo mismo que if(key != NO_KEY)
val = digitalRead(rowPins[8,9]); // lee valor input y lo guarda en val
delay(10); // 10 milisegundos es un buen tiempo.
{
switch (key)
{
case '1':
digitalWrite(ledpin, LOW);
lightMode = 1; // los enciende
break;
case '2':
digitalWrite(ledpin, HIGH);
lightMode = 2; // los pone a parpadear
break;
case '3':
digitalWrite(ledpin, LOW);
lightMode = 3; // hace la ola der. "onda"
break;
case '4':
digitalWrite(ledpin, HIGH);
lightMode = 4; // hace la ola izq.!
break;
case '5':
digitalWrite(ledpin, LOW);
lightMode = 5; // parpadea 1/2!
break;
case '6':
digitalWrite(ledpin, HIGH);
lightMode = 0; // apaga todo!
break;
default:
Serial.println(key);
}
buttonState = val; //guarda el nuevo estado la variable
}
// Ahora hacer lo que lightMode indica
if (lightMode == 0) { // todo apagado
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
}
if (lightMode == 1) { // todo luce
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
}
if (lightMode == 2) { // parpadeo
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
delay(100);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
delay(100);
}
if (lightMode == 3) { // "onda der."
digitalWrite(ledpin6, LOW);
digitalWrite(ledpin1, HIGH);
delay(50);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, HIGH);
delay(50);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, HIGH);
delay(50);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin4, HIGH);
delay(50);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, HIGH);
delay(50);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, HIGH);
delay(50);
}
if (lightMode == 4) { // "onda izq."
digitalWrite(ledpin6, LOW);
digitalWrite(ledpin5, HIGH);
delay(50);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin4, HIGH);
delay(50);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin3, HIGH);
delay(50);
digitalWrite(ledpin3, LOW);
digitalWrite(ledpin2, HIGH);
delay(50);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin1, HIGH);
delay(50);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin6, HIGH);
delay(50);
}
if (lightMode == 5) { // 1/2 + 1/2 parpadeo
digitalWrite(ledpin1, HIGH);
digitalWrite(ledpin2, HIGH);
digitalWrite(ledpin3, HIGH);
delay(100);
digitalWrite(ledpin1, LOW);
digitalWrite(ledpin2, LOW);
digitalWrite(ledpin3, LOW);
delay(100);
digitalWrite(ledpin4, HIGH);
digitalWrite(ledpin5, HIGH);
digitalWrite(ledpin6, HIGH);
delay(100);
digitalWrite(ledpin4, LOW);
digitalWrite(ledpin5, LOW);
digitalWrite(ledpin6, LOW);
delay(100);
}
}

Los diodos LED que he utilizado son de alta eficiencia, alimentados a 3V y en serie con una resistencia de 100, consumen 3mA (miliamperios), si los LEDs no parecen muy iluminados, la causa puede ser una resistencia interna conectada en RPA (pullup). La solución es establecer tal pin como salida con la función pinMode(). Puede copiar y pegar este listado en su plataforma Arduino, para comprobar el buen funcionamiento de la nueva versión del código, aquí. Una demostración con vídeo de baja calidad( aquí )

Llegados aquí, una vez cargado en el Arduino, podemos desconectar la conexión USB o Serial, la aplicación programada seguirá en el microprocesador, a la espera de que lo alimentemos por su entrada de tensión, debe funcionar como esta previsto.

Esto es todo por el momento. Como siempre, se agradecerán los comentarios que se reciban.

Mi agradecimiento especial al inestimable documentación de Arduino ¡y gracias a mucha gente de apoyo en el Foro Arduino!

flecha

Esto es todo, por este simple tutorial, los que quieran leer más sobre el tema Arduino, revele esta sección. ( Mostrar/Ocultar)


Volver al índice de artículos Arduino.

Creada el: 25-07-09 
Actualizada el: 26-03-14     
Licencia de Creative Commons
Desarrollado por: hispavila.com 1998, 2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014
Como se puede comprobar, no tenemos patrocinador. Sin anuncios que molesten, esto lo agradece el lector.
Desde que se inició la andadura, en 1998 hasta el momento, el mantenimiento de este sitio, lo asume el propio autor.
Este obra está bajo una licencia de Creative Commons Reconocimiento-CompartirIgual 3.0 Unported.
Hispavila.com. | | declaración de privacidad | LSSI
| Póngase en contacto con nosotros