|
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.
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.
 
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.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 puede
* cambiar los números debajo 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
*/
#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.
- - Define los pines que corresponde a las filas y a las columnas.
- - Crea el "teclado" que exije dicha librería que se llama Keypad.
- - Define las salidas, en este caso sólo emplea un LED (el propio pin13, del Arduino.
- - Le sigue la configuración de las E/S ("el setup") y las comunicaciones con el PC.
- - Una simple pero efectiva rutina para identificar la tecla (pulsador) presionado.
- - 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:
- 1.- Vaya al menú Sketch/Import Library>
- 2.- Busque dicha librería en este listado. Si no aparece
- 3.- Debe ir a: c:/Arduino0013/hardware/libraries y pegue la
carpeta Keypad que descargó, en dicho lugar
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.
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.
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:
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:
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.
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.
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.
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.
- En primer lugar definiremos los pines correspondientes a los LED's
que usaremos para identificar las salidas, en lugar de relés u otro tipo
de dispositivo para manejar las cargas de cada salida.
- Definimos las variables que necesitamos (val, val2, buttonState y lightMode) como enteros (int).
- En el setup, establecemos los estados de los pines, comunicación serie, librerías, etc.
- El lazo principal y las subrutinas para finalizar.
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.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
void setup() {
pinMode(ledpin, OUTPUT);
// digitalWrite(ledpin1, HIGH); // activa la resistencia polarización alta
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 el 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.
Mejorando 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.
/* 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 comunicación Serie a 9600 bps, usado para depuración.
buttonState = digitalRead(rowPins[8,9]); // lee el 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);
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 aparentan funcionar, pero no parecen muy iluminados,
la causa puede ser una resistencia interna conectada en pullup. La solución es establecer el 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!
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: 25-08-10
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.
| declaración de privacidad | LSSI | Póngase en contacto con nosotros
.
|
TECLADO NUMÉRICO (keypad).